PageRenderTime 102ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 1ms

/Zend/zend_vm_def.h

http://github.com/php/php-src
C Header | 9217 lines | 7916 code | 1092 blank | 209 comment | 3120 complexity | 269e6b1c43e0bd1cf797e3fe4f21d39d MD5 | raw file
Possible License(s): BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, LGPL-2.1 
    

  1. /*
    2. 

  2.    +----------------------------------------------------------------------+
    3. 

  3.    | Zend Engine                                                          |
    4. 

  4.    +----------------------------------------------------------------------+
    5. 

  5.    | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
    6. 

  6.    +----------------------------------------------------------------------+
    7. 

  7.    | This source file is subject to version 2.00 of the Zend license,     |
    8. 

  8.    | that is bundled with this package in the file LICENSE, and is        |
    9. 

  9.    | available through the world-wide-web at the following url:           |
    10. 

  10.    | http://www.zend.com/license/2_00.txt.                                |
    11. 

  11.    | If you did not receive a copy of the Zend license and are unable to  |
    12. 

  12.    | obtain it through the world-wide-web, please send a note to          |
    13. 

  13.    | license@zend.com so we can mail you a copy immediately.              |
    14. 

  14.    +----------------------------------------------------------------------+
    15. 

  15.    | Authors: Andi Gutmans <andi@php.net>                                 |
    16. 

  16.    |          Zeev Suraski <zeev@php.net>                                 |
    17. 

  17.    |          Dmitry Stogov <dmitry@php.net>                              |
    18. 

  18.    +----------------------------------------------------------------------+
    19. 

  19. */
    20. 

  20. 

  21. /* If you change this file, please regenerate the zend_vm_execute.h and
    22. 

  22.  * zend_vm_opcodes.h files by running:
    23. 

  23.  * php zend_vm_gen.php
    24. 

  24.  */
    25. 

  25. 

  26. ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2)
    27. 

  27. {
    28. 

  28. 	USE_OPLINE
    29. 

  29. 

  30. 	SAVE_OPLINE();
    31. 

  31. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    32. 

  32. 		op_1 = ZVAL_UNDEFINED_OP1();
    33. 

  33. 	}
    34. 

  34. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    35. 

  35. 		op_2 = ZVAL_UNDEFINED_OP2();
    36. 

  36. 	}
    37. 

  37. 	add_function(EX_VAR(opline->result.var), op_1, op_2);
    38. 

  38. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    39. 

  39. 		zval_ptr_dtor_nogc(op_1);
    40. 

  40. 	}
    41. 

  41. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    42. 

  42. 		zval_ptr_dtor_nogc(op_2);
    43. 

  43. 	}
    44. 

  44. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    45. 

  45. }
    46. 

  46. 

  47. ZEND_VM_HOT_NOCONSTCONST_HANDLER(1, ZEND_ADD, CONST|TMPVARCV, CONST|TMPVARCV)
    48. 

  48. {
    49. 

  49. 	USE_OPLINE
    50. 

  50. 	zval *op1, *op2, *result;
    51. 

  51. 	double d1, d2;
    52. 

  52. 

  53. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    54. 

  54. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    55. 

  55. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    56. 

  56. 		/* pass */
    57. 

  57. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
    58. 

  58. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    59. 

  59. 			result = EX_VAR(opline->result.var);
    60. 

  60. 			fast_long_add_function(result, op1, op2);
    61. 

  61. 			ZEND_VM_NEXT_OPCODE();
    62. 

  62. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    63. 

  63. 			d1 = (double)Z_LVAL_P(op1);
    64. 

  64. 			d2 = Z_DVAL_P(op2);
    65. 

  65. 			ZEND_VM_C_GOTO(add_double);
    66. 

  66. 		}
    67. 

  67. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
    68. 

  68. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    69. 

  69. 			d1 = Z_DVAL_P(op1);
    70. 

  70. 			d2 = Z_DVAL_P(op2);
    71. 

  71. ZEND_VM_C_LABEL(add_double):
    72. 

  72. 			result = EX_VAR(opline->result.var);
    73. 

  73. 			ZVAL_DOUBLE(result, d1 + d2);
    74. 

  74. 			ZEND_VM_NEXT_OPCODE();
    75. 

  75. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    76. 

  76. 			d1 = Z_DVAL_P(op1);
    77. 

  77. 			d2 = (double)Z_LVAL_P(op2);
    78. 

  78. 			ZEND_VM_C_GOTO(add_double);
    79. 

  79. 		}
    80. 

  80. 	}
    81. 

  81. 

  82. 	ZEND_VM_DISPATCH_TO_HELPER(zend_add_helper, op_1, op1, op_2, op2);
    83. 

  83. }
    84. 

  84. 

  85. ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2)
    86. 

  86. {
    87. 

  87. 	USE_OPLINE
    88. 

  88. 

  89. 	SAVE_OPLINE();
    90. 

  90. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    91. 

  91. 		op_1 = ZVAL_UNDEFINED_OP1();
    92. 

  92. 	}
    93. 

  93. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    94. 

  94. 		op_2 = ZVAL_UNDEFINED_OP2();
    95. 

  95. 	}
    96. 

  96. 	sub_function(EX_VAR(opline->result.var), op_1, op_2);
    97. 

  97. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    98. 

  98. 		zval_ptr_dtor_nogc(op_1);
    99. 

  99. 	}
    100. 

  100. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    101. 

  101. 		zval_ptr_dtor_nogc(op_2);
    102. 

  102. 	}
    103. 

  103. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    104. 

  104. }
    105. 

  105. 

  106. ZEND_VM_HOT_NOCONSTCONST_HANDLER(2, ZEND_SUB, CONST|TMPVARCV, CONST|TMPVARCV)
    107. 

  107. {
    108. 

  108. 	USE_OPLINE
    109. 

  109. 	zval *op1, *op2, *result;
    110. 

  110. 	double d1, d2;
    111. 

  111. 

  112. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    113. 

  113. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    114. 

  114. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    115. 

  115. 		/* pass */
    116. 

  116. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
    117. 

  117. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    118. 

  118. 			result = EX_VAR(opline->result.var);
    119. 

  119. 			fast_long_sub_function(result, op1, op2);
    120. 

  120. 			ZEND_VM_NEXT_OPCODE();
    121. 

  121. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    122. 

  122. 			d1 = (double)Z_LVAL_P(op1);
    123. 

  123. 			d2 = Z_DVAL_P(op2);
    124. 

  124. 			ZEND_VM_C_GOTO(sub_double);
    125. 

  125. 		}
    126. 

  126. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
    127. 

  127. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    128. 

  128. 			d1 = Z_DVAL_P(op1);
    129. 

  129. 			d2 = Z_DVAL_P(op2);
    130. 

  130. ZEND_VM_C_LABEL(sub_double):
    131. 

  131. 			result = EX_VAR(opline->result.var);
    132. 

  132. 			ZVAL_DOUBLE(result, d1 - d2);
    133. 

  133. 			ZEND_VM_NEXT_OPCODE();
    134. 

  134. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    135. 

  135. 			d1 = Z_DVAL_P(op1);
    136. 

  136. 			d2 = (double)Z_LVAL_P(op2);
    137. 

  137. 			ZEND_VM_C_GOTO(sub_double);
    138. 

  138. 		}
    139. 

  139. 	}
    140. 

  140. 

  141. 	ZEND_VM_DISPATCH_TO_HELPER(zend_sub_helper, op_1, op1, op_2, op2);
    142. 

  142. }
    143. 

  143. 

  144. ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2)
    145. 

  145. {
    146. 

  146. 	USE_OPLINE
    147. 

  147. 

  148. 	SAVE_OPLINE();
    149. 

  149. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    150. 

  150. 		op_1 = ZVAL_UNDEFINED_OP1();
    151. 

  151. 	}
    152. 

  152. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    153. 

  153. 		op_2 = ZVAL_UNDEFINED_OP2();
    154. 

  154. 	}
    155. 

  155. 	mul_function(EX_VAR(opline->result.var), op_1, op_2);
    156. 

  156. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    157. 

  157. 		zval_ptr_dtor_nogc(op_1);
    158. 

  158. 	}
    159. 

  159. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    160. 

  160. 		zval_ptr_dtor_nogc(op_2);
    161. 

  161. 	}
    162. 

  162. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    163. 

  163. }
    164. 

  164. 

  165. ZEND_VM_COLD_CONSTCONST_HANDLER(3, ZEND_MUL, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(COMMUTATIVE))
    166. 

  166. {
    167. 

  167. 	USE_OPLINE
    168. 

  168. 	zval *op1, *op2, *result;
    169. 

  169. 	double d1, d2;
    170. 

  170. 

  171. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    172. 

  172. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    173. 

  173. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    174. 

  174. 		/* pass */
    175. 

  175. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
    176. 

  176. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    177. 

  177. 			zend_long overflow;
    178. 

  178. 

  179. 			result = EX_VAR(opline->result.var);
    180. 

  180. 			ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
    181. 

  181. 			Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
    182. 

  182. 			ZEND_VM_NEXT_OPCODE();
    183. 

  183. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    184. 

  184. 			d1 = (double)Z_LVAL_P(op1);
    185. 

  185. 			d2 = Z_DVAL_P(op2);
    186. 

  186. 			ZEND_VM_C_GOTO(mul_double);
    187. 

  187. 		}
    188. 

  188. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
    189. 

  189. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    190. 

  190. 			d1 = Z_DVAL_P(op1);
    191. 

  191. 			d2 = Z_DVAL_P(op2);
    192. 

  192. ZEND_VM_C_LABEL(mul_double):
    193. 

  193. 			result = EX_VAR(opline->result.var);
    194. 

  194. 			ZVAL_DOUBLE(result, d1 * d2);
    195. 

  195. 			ZEND_VM_NEXT_OPCODE();
    196. 

  196. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    197. 

  197. 			d1 = Z_DVAL_P(op1);
    198. 

  198. 			d2 = (double)Z_LVAL_P(op2);
    199. 

  199. 			ZEND_VM_C_GOTO(mul_double);
    200. 

  200. 		}
    201. 

  201. 	}
    202. 

  202. 

  203. 	ZEND_VM_DISPATCH_TO_HELPER(zend_mul_helper, op_1, op1, op_2, op2);
    204. 

  204. }
    205. 

  205. 

  206. ZEND_VM_COLD_CONSTCONST_HANDLER(4, ZEND_DIV, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
    207. 

  207. {
    208. 

  208. 	USE_OPLINE
    209. 

  209. 	zval *op1, *op2;
    210. 

  210. 

  211. 	SAVE_OPLINE();
    212. 

  212. 	op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
    213. 

  213. 	op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
    214. 

  214. 	fast_div_function(EX_VAR(opline->result.var), op1, op2);
    215. 

  215. 	FREE_OP1();
    216. 

  216. 	FREE_OP2();
    217. 

  217. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    218. 

  218. }
    219. 

  219. 

  220. ZEND_VM_COLD_HELPER(zend_mod_by_zero_helper, ANY, ANY)
    221. 

  221. {
    222. 

  222. 	USE_OPLINE
    223. 

  223. 

  224. 	SAVE_OPLINE();
    225. 

  225. 	zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero");
    226. 

  226. 	ZVAL_UNDEF(EX_VAR(opline->result.var));
    227. 

  227. 	HANDLE_EXCEPTION();
    228. 

  228. }
    229. 

  229. 

  230. ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2)
    231. 

  231. {
    232. 

  232. 	USE_OPLINE
    233. 

  233. 

  234. 	SAVE_OPLINE();
    235. 

  235. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    236. 

  236. 		op_1 = ZVAL_UNDEFINED_OP1();
    237. 

  237. 	}
    238. 

  238. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    239. 

  239. 		op_2 = ZVAL_UNDEFINED_OP2();
    240. 

  240. 	}
    241. 

  241. 	mod_function(EX_VAR(opline->result.var), op_1, op_2);
    242. 

  242. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    243. 

  243. 		zval_ptr_dtor_nogc(op_1);
    244. 

  244. 	}
    245. 

  245. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    246. 

  246. 		zval_ptr_dtor_nogc(op_2);
    247. 

  247. 	}
    248. 

  248. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    249. 

  249. }
    250. 

  250. 

  251. ZEND_VM_COLD_CONSTCONST_HANDLER(5, ZEND_MOD, CONST|TMPVARCV, CONST|TMPVARCV)
    252. 

  252. {
    253. 

  253. 	USE_OPLINE
    254. 

  254. 	zval *op1, *op2, *result;
    255. 

  255. 

  256. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    257. 

  257. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    258. 

  258. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    259. 

  259. 		/* pass */
    260. 

  260. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
    261. 

  261. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    262. 

  262. 			result = EX_VAR(opline->result.var);
    263. 

  263. 			if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
    264. 

  264. 				ZEND_VM_DISPATCH_TO_HELPER(zend_mod_by_zero_helper);
    265. 

  265. 			} else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
    266. 

  266. 				/* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
    267. 

  267. 				ZVAL_LONG(result, 0);
    268. 

  268. 			} else {
    269. 

  269. 				ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
    270. 

  270. 			}
    271. 

  271. 			ZEND_VM_NEXT_OPCODE();
    272. 

  272. 		}
    273. 

  273. 	}
    274. 

  274. 

  275. 	ZEND_VM_DISPATCH_TO_HELPER(zend_mod_helper, op_1, op1, op_2, op2);
    276. 

  276. }
    277. 

  277. 

  278. ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2)
    279. 

  279. {
    280. 

  280. 	USE_OPLINE
    281. 

  281. 

  282. 	SAVE_OPLINE();
    283. 

  283. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    284. 

  284. 		op_1 = ZVAL_UNDEFINED_OP1();
    285. 

  285. 	}
    286. 

  286. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    287. 

  287. 		op_2 = ZVAL_UNDEFINED_OP2();
    288. 

  288. 	}
    289. 

  289. 	shift_left_function(EX_VAR(opline->result.var), op_1, op_2);
    290. 

  290. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    291. 

  291. 		zval_ptr_dtor_nogc(op_1);
    292. 

  292. 	}
    293. 

  293. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    294. 

  294. 		zval_ptr_dtor_nogc(op_2);
    295. 

  295. 	}
    296. 

  296. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    297. 

  297. }
    298. 

  298. 

  299. ZEND_VM_COLD_CONSTCONST_HANDLER(6, ZEND_SL, CONST|TMPVARCV, CONST|TMPVARCV)
    300. 

  300. {
    301. 

  301. 	USE_OPLINE
    302. 

  302. 	zval *op1, *op2;
    303. 

  303. 

  304. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    305. 

  305. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    306. 

  306. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    307. 

  307. 		/* pass */
    308. 

  308. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
    309. 

  309. 			&& EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
    310. 

  310. 			&& EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
    311. 

  311. 		/* Perform shift on unsigned numbers to get well-defined wrap behavior. */
    312. 

  312. 		ZVAL_LONG(EX_VAR(opline->result.var),
    313. 

  313. 			(zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
    314. 

  314. 		ZEND_VM_NEXT_OPCODE();
    315. 

  315. 	}
    316. 

  316. 

  317. 	ZEND_VM_DISPATCH_TO_HELPER(zend_shift_left_helper, op_1, op1, op_2, op2);
    318. 

  318. }
    319. 

  319. 

  320. ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2)
    321. 

  321. {
    322. 

  322. 	USE_OPLINE
    323. 

  323. 

  324. 	SAVE_OPLINE();
    325. 

  325. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    326. 

  326. 		op_1 = ZVAL_UNDEFINED_OP1();
    327. 

  327. 	}
    328. 

  328. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    329. 

  329. 		op_2 = ZVAL_UNDEFINED_OP2();
    330. 

  330. 	}
    331. 

  331. 	shift_right_function(EX_VAR(opline->result.var), op_1, op_2);
    332. 

  332. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    333. 

  333. 		zval_ptr_dtor_nogc(op_1);
    334. 

  334. 	}
    335. 

  335. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    336. 

  336. 		zval_ptr_dtor_nogc(op_2);
    337. 

  337. 	}
    338. 

  338. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    339. 

  339. }
    340. 

  340. 

  341. ZEND_VM_COLD_CONSTCONST_HANDLER(7, ZEND_SR, CONST|TMPVARCV, CONST|TMPVARCV)
    342. 

  342. {
    343. 

  343. 	USE_OPLINE
    344. 

  344. 	zval *op1, *op2;
    345. 

  345. 

  346. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    347. 

  347. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    348. 

  348. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    349. 

  349. 		/* pass */
    350. 

  350. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
    351. 

  351. 			&& EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
    352. 

  352. 			&& EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
    353. 

  353. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
    354. 

  354. 		ZEND_VM_NEXT_OPCODE();
    355. 

  355. 	}
    356. 

  356. 

  357. 	ZEND_VM_DISPATCH_TO_HELPER(zend_shift_right_helper, op_1, op1, op_2, op2);
    358. 

  358. }
    359. 

  359. 

  360. ZEND_VM_COLD_CONSTCONST_HANDLER(12, ZEND_POW, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
    361. 

  361. {
    362. 

  362. 	USE_OPLINE
    363. 

  363. 	zval *op1, *op2;
    364. 

  364. 

  365. 	SAVE_OPLINE();
    366. 

  366. 	op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
    367. 

  367. 	op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
    368. 

  368. 	pow_function(EX_VAR(opline->result.var), op1, op2);
    369. 

  369. 	FREE_OP1();
    370. 

  370. 	FREE_OP2();
    371. 

  371. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    372. 

  372. }
    373. 

  373. 

  374. ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(NO_CONST_CONST))
    375. 

  375. {
    376. 

  376. 	USE_OPLINE
    377. 

  377. 	zval *op1, *op2;
    378. 

  378. 

  379. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    380. 

  380. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    381. 

  381. 

  382. 	if ((OP1_TYPE == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
    383. 

  383. 	    (OP2_TYPE == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
    384. 

  384. 		zend_string *op1_str = Z_STR_P(op1);
    385. 

  385. 		zend_string *op2_str = Z_STR_P(op2);
    386. 

  386. 		zend_string *str;
    387. 

  387. 

  388. 		if (OP1_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
    389. 

  389. 			if (OP2_TYPE == IS_CONST || OP2_TYPE == IS_CV) {
    390. 

  390. 				ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
    391. 

  391. 			} else {
    392. 

  392. 				ZVAL_STR(EX_VAR(opline->result.var), op2_str);
    393. 

  393. 			}
    394. 

  394. 			if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    395. 

  395. 				zend_string_release_ex(op1_str, 0);
    396. 

  396. 			}
    397. 

  397. 		} else if (OP2_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
    398. 

  398. 			if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_CV) {
    399. 

  399. 				ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
    400. 

  400. 			} else {
    401. 

  401. 				ZVAL_STR(EX_VAR(opline->result.var), op1_str);
    402. 

  402. 			}
    403. 

  403. 			if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    404. 

  404. 				zend_string_release_ex(op2_str, 0);
    405. 

  405. 			}
    406. 

  406. 		} else if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
    407. 

  407. 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
    408. 

  408. 		    size_t len = ZSTR_LEN(op1_str);
    409. 

  409. 

  410. 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
    411. 

  411. 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
    412. 

  412. 			ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
    413. 

  413. 			if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    414. 

  414. 				zend_string_release_ex(op2_str, 0);
    415. 

  415. 			}
    416. 

  416. 		} else {
    417. 

  417. 			str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
    418. 

  418. 			memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
    419. 

  419. 			memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
    420. 

  420. 			ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
    421. 

  421. 			if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    422. 

  422. 				zend_string_release_ex(op1_str, 0);
    423. 

  423. 			}
    424. 

  424. 			if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    425. 

  425. 				zend_string_release_ex(op2_str, 0);
    426. 

  426. 			}
    427. 

  427. 		}
    428. 

  428. 		ZEND_VM_NEXT_OPCODE();
    429. 

  429. 	} else {
    430. 

  430. 		SAVE_OPLINE();
    431. 

  431. 

  432. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
    433. 

  433. 			op1 = ZVAL_UNDEFINED_OP1();
    434. 

  434. 		}
    435. 

  435. 		if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
    436. 

  436. 			op2 = ZVAL_UNDEFINED_OP2();
    437. 

  437. 		}
    438. 

  438. 		concat_function(EX_VAR(opline->result.var), op1, op2);
    439. 

  439. 		FREE_OP1();
    440. 

  440. 		FREE_OP2();
    441. 

  441. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    442. 

  442. 	}
    443. 

  443. }
    444. 

  444. 

  445. ZEND_VM_COLD_CONSTCONST_HANDLER(16, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV, SPEC(COMMUTATIVE))
    446. 

  446. {
    447. 

  447. 	USE_OPLINE
    448. 

  448. 	zval *op1, *op2;
    449. 

  449. 	zend_bool result;
    450. 

  450. 

  451. 	SAVE_OPLINE();
    452. 

  452. 	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
    453. 

  453. 	op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
    454. 

  454. 	result = fast_is_identical_function(op1, op2);
    455. 

  455. 	FREE_OP1();
    456. 

  456. 	FREE_OP2();
    457. 

  457. 	ZEND_VM_SMART_BRANCH(result, 1);
    458. 

  458. }
    459. 

  459. 

  460. ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV, SPEC(COMMUTATIVE))
    461. 

  461. {
    462. 

  462. 	USE_OPLINE
    463. 

  463. 	zval *op1, *op2;
    464. 

  464. 	zend_bool result;
    465. 

  465. 

  466. 	SAVE_OPLINE();
    467. 

  467. 	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
    468. 

  468. 	op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
    469. 

  469. 	result = fast_is_not_identical_function(op1, op2);
    470. 

  470. 	FREE_OP1();
    471. 

  471. 	FREE_OP2();
    472. 

  472. 	ZEND_VM_SMART_BRANCH(result, 1);
    473. 

  473. }
    474. 

  474. 

  475. ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
    476. 

  476. {
    477. 

  477. 	int ret;
    478. 

  478. 	USE_OPLINE
    479. 

  479. 

  480. 	SAVE_OPLINE();
    481. 

  481. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    482. 

  482. 		op_1 = ZVAL_UNDEFINED_OP1();
    483. 

  483. 	}
    484. 

  484. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    485. 

  485. 		op_2 = ZVAL_UNDEFINED_OP2();
    486. 

  486. 	}
    487. 

  487. 	ret = zend_compare(op_1, op_2);
    488. 

  488. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    489. 

  489. 		zval_ptr_dtor_nogc(op_1);
    490. 

  490. 	}
    491. 

  491. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    492. 

  492. 		zval_ptr_dtor_nogc(op_2);
    493. 

  493. 	}
    494. 

  494. 	ZEND_VM_SMART_BRANCH(ret == 0, 1);
    495. 

  495. }
    496. 

  496. 

  497. ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(SMART_BRANCH,COMMUTATIVE))
    498. 

  498. {
    499. 

  499. 	USE_OPLINE
    500. 

  500. 	zval *op1, *op2;
    501. 

  501. 	double d1, d2;
    502. 

  502. 

  503. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    504. 

  504. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    505. 

  505. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    506. 

  506. 		/* pass */
    507. 

  507. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
    508. 

  508. 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    509. 

  509. 			if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
    510. 

  510. ZEND_VM_C_LABEL(is_equal_true):
    511. 

  511. 				ZEND_VM_SMART_BRANCH_TRUE();
    512. 

  512. 			} else {
    513. 

  513. ZEND_VM_C_LABEL(is_equal_false):
    514. 

  514. 				ZEND_VM_SMART_BRANCH_FALSE();
    515. 

  515. 			}
    516. 

  516. 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
    517. 

  517. 			d1 = (double)Z_LVAL_P(op1);
    518. 

  518. 			d2 = Z_DVAL_P(op2);
    519. 

  519. 			ZEND_VM_C_GOTO(is_equal_double);
    520. 

  520. 		}
    521. 

  521. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
    522. 

  522. 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
    523. 

  523. 			d1 = Z_DVAL_P(op1);
    524. 

  524. 			d2 = Z_DVAL_P(op2);
    525. 

  525. ZEND_VM_C_LABEL(is_equal_double):
    526. 

  526. 			if (d1 == d2) {
    527. 

  527. 				ZEND_VM_C_GOTO(is_equal_true);
    528. 

  528. 			} else {
    529. 

  529. 				ZEND_VM_C_GOTO(is_equal_false);
    530. 

  530. 			}
    531. 

  531. 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    532. 

  532. 			d1 = Z_DVAL_P(op1);
    533. 

  533. 			d2 = (double)Z_LVAL_P(op2);
    534. 

  534. 			ZEND_VM_C_GOTO(is_equal_double);
    535. 

  535. 		}
    536. 

  536. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
    537. 

  537. 		if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
    538. 

  538. 			int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
    539. 

  539. 			if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    540. 

  540. 				zval_ptr_dtor_str(op1);
    541. 

  541. 			}
    542. 

  542. 			if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    543. 

  543. 				zval_ptr_dtor_str(op2);
    544. 

  544. 			}
    545. 

  545. 			if (result) {
    546. 

  546. 				ZEND_VM_C_GOTO(is_equal_true);
    547. 

  547. 			} else {
    548. 

  548. 				ZEND_VM_C_GOTO(is_equal_false);
    549. 

  549. 			}
    550. 

  550. 		}
    551. 

  551. 	}
    552. 

  552. 	ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper, op_1, op1, op_2, op2);
    553. 

  553. }
    554. 

  554. 

  555. ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
    556. 

  556. {
    557. 

  557. 	int ret;
    558. 

  558. 	USE_OPLINE
    559. 

  559. 

  560. 	SAVE_OPLINE();
    561. 

  561. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    562. 

  562. 		op_1 = ZVAL_UNDEFINED_OP1();
    563. 

  563. 	}
    564. 

  564. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    565. 

  565. 		op_2 = ZVAL_UNDEFINED_OP2();
    566. 

  566. 	}
    567. 

  567. 	ret = zend_compare(op_1, op_2);
    568. 

  568. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    569. 

  569. 		zval_ptr_dtor_nogc(op_1);
    570. 

  570. 	}
    571. 

  571. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    572. 

  572. 		zval_ptr_dtor_nogc(op_2);
    573. 

  573. 	}
    574. 

  574. 	ZEND_VM_SMART_BRANCH(ret != 0, 1);
    575. 

  575. }
    576. 

  576. 

  577. ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(SMART_BRANCH,COMMUTATIVE))
    578. 

  578. {
    579. 

  579. 	USE_OPLINE
    580. 

  580. 	zval *op1, *op2;
    581. 

  581. 	double d1, d2;
    582. 

  582. 

  583. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    584. 

  584. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    585. 

  585. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    586. 

  586. 		/* pass */
    587. 

  587. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
    588. 

  588. 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    589. 

  589. 			if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
    590. 

  590. ZEND_VM_C_LABEL(is_not_equal_true):
    591. 

  591. 				ZEND_VM_SMART_BRANCH_TRUE();
    592. 

  592. 			} else {
    593. 

  593. ZEND_VM_C_LABEL(is_not_equal_false):
    594. 

  594. 				ZEND_VM_SMART_BRANCH_FALSE();
    595. 

  595. 			}
    596. 

  596. 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
    597. 

  597. 			d1 = (double)Z_LVAL_P(op1);
    598. 

  598. 			d2 = Z_DVAL_P(op2);
    599. 

  599. 			ZEND_VM_C_GOTO(is_not_equal_double);
    600. 

  600. 		}
    601. 

  601. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
    602. 

  602. 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
    603. 

  603. 			d1 = Z_DVAL_P(op1);
    604. 

  604. 			d2 = Z_DVAL_P(op2);
    605. 

  605. ZEND_VM_C_LABEL(is_not_equal_double):
    606. 

  606. 			if (d1 != d2) {
    607. 

  607. 				ZEND_VM_C_GOTO(is_not_equal_true);
    608. 

  608. 			} else {
    609. 

  609. 				ZEND_VM_C_GOTO(is_not_equal_false);
    610. 

  610. 			}
    611. 

  611. 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    612. 

  612. 			d1 = Z_DVAL_P(op1);
    613. 

  613. 			d2 = (double)Z_LVAL_P(op2);
    614. 

  614. 			ZEND_VM_C_GOTO(is_not_equal_double);
    615. 

  615. 		}
    616. 

  616. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
    617. 

  617. 		if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
    618. 

  618. 			int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
    619. 

  619. 			if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    620. 

  620. 				zval_ptr_dtor_str(op1);
    621. 

  621. 			}
    622. 

  622. 			if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    623. 

  623. 				zval_ptr_dtor_str(op2);
    624. 

  624. 			}
    625. 

  625. 			if (!result) {
    626. 

  626. 				ZEND_VM_C_GOTO(is_not_equal_true);
    627. 

  627. 			} else {
    628. 

  628. 				ZEND_VM_C_GOTO(is_not_equal_false);
    629. 

  629. 			}
    630. 

  630. 		}
    631. 

  631. 	}
    632. 

  632. 	ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper, op_1, op1, op_2, op2);
    633. 

  633. }
    634. 

  634. 

  635. ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2)
    636. 

  636. {
    637. 

  637. 	int ret;
    638. 

  638. 	USE_OPLINE
    639. 

  639. 

  640. 	SAVE_OPLINE();
    641. 

  641. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    642. 

  642. 		op_1 = ZVAL_UNDEFINED_OP1();
    643. 

  643. 	}
    644. 

  644. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    645. 

  645. 		op_2 = ZVAL_UNDEFINED_OP2();
    646. 

  646. 	}
    647. 

  647. 	ret = zend_compare(op_1, op_2);
    648. 

  648. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    649. 

  649. 		zval_ptr_dtor_nogc(op_1);
    650. 

  650. 	}
    651. 

  651. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    652. 

  652. 		zval_ptr_dtor_nogc(op_2);
    653. 

  653. 	}
    654. 

  654. 	ZEND_VM_SMART_BRANCH(ret < 0, 1);
    655. 

  655. }
    656. 

  656. 

  657. ZEND_VM_HOT_NOCONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH))
    658. 

  658. {
    659. 

  659. 	USE_OPLINE
    660. 

  660. 	zval *op1, *op2;
    661. 

  661. 	double d1, d2;
    662. 

  662. 

  663. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    664. 

  664. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    665. 

  665. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    666. 

  666. 		/* pass */
    667. 

  667. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
    668. 

  668. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    669. 

  669. 			if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
    670. 

  670. ZEND_VM_C_LABEL(is_smaller_true):
    671. 

  671. 				ZEND_VM_SMART_BRANCH_TRUE();
    672. 

  672. 			} else {
    673. 

  673. ZEND_VM_C_LABEL(is_smaller_false):
    674. 

  674. 				ZEND_VM_SMART_BRANCH_FALSE();
    675. 

  675. 			}
    676. 

  676. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    677. 

  677. 			d1 = (double)Z_LVAL_P(op1);
    678. 

  678. 			d2 = Z_DVAL_P(op2);
    679. 

  679. 			ZEND_VM_C_GOTO(is_smaller_double);
    680. 

  680. 		}
    681. 

  681. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
    682. 

  682. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    683. 

  683. 			d1 = Z_DVAL_P(op1);
    684. 

  684. 			d2 = Z_DVAL_P(op2);
    685. 

  685. ZEND_VM_C_LABEL(is_smaller_double):
    686. 

  686. 			if (d1 < d2) {
    687. 

  687. 				ZEND_VM_C_GOTO(is_smaller_true);
    688. 

  688. 			} else {
    689. 

  689. 				ZEND_VM_C_GOTO(is_smaller_false);
    690. 

  690. 			}
    691. 

  691. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    692. 

  692. 			d1 = Z_DVAL_P(op1);
    693. 

  693. 			d2 = (double)Z_LVAL_P(op2);
    694. 

  694. 			ZEND_VM_C_GOTO(is_smaller_double);
    695. 

  695. 		}
    696. 

  696. 	}
    697. 

  697. 	ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_helper, op_1, op1, op_2, op2);
    698. 

  698. }
    699. 

  699. 

  700. ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
    701. 

  701. {
    702. 

  702. 	int ret;
    703. 

  703. 	USE_OPLINE
    704. 

  704. 

  705. 	SAVE_OPLINE();
    706. 

  706. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    707. 

  707. 		op_1 = ZVAL_UNDEFINED_OP1();
    708. 

  708. 	}
    709. 

  709. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    710. 

  710. 		op_2 = ZVAL_UNDEFINED_OP2();
    711. 

  711. 	}
    712. 

  712. 	ret = zend_compare(op_1, op_2);
    713. 

  713. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    714. 

  714. 		zval_ptr_dtor_nogc(op_1);
    715. 

  715. 	}
    716. 

  716. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    717. 

  717. 		zval_ptr_dtor_nogc(op_2);
    718. 

  718. 	}
    719. 

  719. 	ZEND_VM_SMART_BRANCH(ret <= 0, 1);
    720. 

  720. }
    721. 

  721. 

  722. ZEND_VM_HOT_NOCONSTCONST_HANDLER(21, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH))
    723. 

  723. {
    724. 

  724. 	USE_OPLINE
    725. 

  725. 	zval *op1, *op2;
    726. 

  726. 	double d1, d2;
    727. 

  727. 

  728. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    729. 

  729. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    730. 

  730. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    731. 

  731. 		/* pass */
    732. 

  732. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
    733. 

  733. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    734. 

  734. 			if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
    735. 

  735. ZEND_VM_C_LABEL(is_smaller_or_equal_true):
    736. 

  736. 				ZEND_VM_SMART_BRANCH_TRUE();
    737. 

  737. 				ZVAL_TRUE(EX_VAR(opline->result.var));
    738. 

  738. 				ZEND_VM_NEXT_OPCODE();
    739. 

  739. 			} else {
    740. 

  740. ZEND_VM_C_LABEL(is_smaller_or_equal_false):
    741. 

  741. 				ZEND_VM_SMART_BRANCH_FALSE();
    742. 

  742. 				ZVAL_FALSE(EX_VAR(opline->result.var));
    743. 

  743. 				ZEND_VM_NEXT_OPCODE();
    744. 

  744. 			}
    745. 

  745. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    746. 

  746. 			d1 = (double)Z_LVAL_P(op1);
    747. 

  747. 			d2 = Z_DVAL_P(op2);
    748. 

  748. 			ZEND_VM_C_GOTO(is_smaller_or_equal_double);
    749. 

  749. 		}
    750. 

  750. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
    751. 

  751. 		if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
    752. 

  752. 			d1 = Z_DVAL_P(op1);
    753. 

  753. 			d2 = Z_DVAL_P(op2);
    754. 

  754. ZEND_VM_C_LABEL(is_smaller_or_equal_double):
    755. 

  755. 			if (d1 <= d2) {
    756. 

  756. 				ZEND_VM_C_GOTO(is_smaller_or_equal_true);
    757. 

  757. 			} else {
    758. 

  758. 				ZEND_VM_C_GOTO(is_smaller_or_equal_false);
    759. 

  759. 			}
    760. 

  760. 		} else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    761. 

  761. 			d1 = Z_DVAL_P(op1);
    762. 

  762. 			d2 = (double)Z_LVAL_P(op2);
    763. 

  763. 			ZEND_VM_C_GOTO(is_smaller_or_equal_double);
    764. 

  764. 		}
    765. 

  765. 	}
    766. 

  766. 	ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_or_equal_helper, op_1, op1, op_2, op2);
    767. 

  767. }
    768. 

  768. 

  769. ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
    770. 

  770. {
    771. 

  771. 	USE_OPLINE
    772. 

  772. 	zval *op1, *op2;
    773. 

  773. 

  774. 	SAVE_OPLINE();
    775. 

  775. 	op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
    776. 

  776. 	op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
    777. 

  777. 	compare_function(EX_VAR(opline->result.var), op1, op2);
    778. 

  778. 	FREE_OP1();
    779. 

  779. 	FREE_OP2();
    780. 

  780. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    781. 

  781. }
    782. 

  782. 

  783. ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2)
    784. 

  784. {
    785. 

  785. 	USE_OPLINE
    786. 

  786. 

  787. 	SAVE_OPLINE();
    788. 

  788. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    789. 

  789. 		op_1 = ZVAL_UNDEFINED_OP1();
    790. 

  790. 	}
    791. 

  791. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    792. 

  792. 		op_2 = ZVAL_UNDEFINED_OP2();
    793. 

  793. 	}
    794. 

  794. 	bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2);
    795. 

  795. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    796. 

  796. 		zval_ptr_dtor_nogc(op_1);
    797. 

  797. 	}
    798. 

  798. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    799. 

  799. 		zval_ptr_dtor_nogc(op_2);
    800. 

  800. 	}
    801. 

  801. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    802. 

  802. }
    803. 

  803. 

  804. ZEND_VM_HOT_NOCONSTCONST_HANDLER(9, ZEND_BW_OR, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(COMMUTATIVE))
    805. 

  805. {
    806. 

  806. 	USE_OPLINE
    807. 

  807. 	zval *op1, *op2;
    808. 

  808. 

  809. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    810. 

  810. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    811. 

  811. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    812. 

  812. 		/* pass */
    813. 

  813. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
    814. 

  814. 			&& EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    815. 

  815. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
    816. 

  816. 		ZEND_VM_NEXT_OPCODE();
    817. 

  817. 	}
    818. 

  818. 

  819. 	ZEND_VM_DISPATCH_TO_HELPER(zend_bw_or_helper, op_1, op1, op_2, op2);
    820. 

  820. }
    821. 

  821. 

  822. ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2)
    823. 

  823. {
    824. 

  824. 	USE_OPLINE
    825. 

  825. 

  826. 	SAVE_OPLINE();
    827. 

  827. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    828. 

  828. 		op_1 = ZVAL_UNDEFINED_OP1();
    829. 

  829. 	}
    830. 

  830. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    831. 

  831. 		op_2 = ZVAL_UNDEFINED_OP2();
    832. 

  832. 	}
    833. 

  833. 	bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2);
    834. 

  834. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    835. 

  835. 		zval_ptr_dtor_nogc(op_1);
    836. 

  836. 	}
    837. 

  837. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    838. 

  838. 		zval_ptr_dtor_nogc(op_2);
    839. 

  839. 	}
    840. 

  840. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    841. 

  841. }
    842. 

  842. 

  843. ZEND_VM_HOT_NOCONSTCONST_HANDLER(10, ZEND_BW_AND, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(COMMUTATIVE))
    844. 

  844. {
    845. 

  845. 	USE_OPLINE
    846. 

  846. 	zval *op1, *op2;
    847. 

  847. 

  848. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    849. 

  849. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    850. 

  850. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    851. 

  851. 		/* pass */
    852. 

  852. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
    853. 

  853. 			&& EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    854. 

  854. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
    855. 

  855. 		ZEND_VM_NEXT_OPCODE();
    856. 

  856. 	}
    857. 

  857. 

  858. 	ZEND_VM_DISPATCH_TO_HELPER(zend_bw_and_helper, op_1, op1, op_2, op2);
    859. 

  859. }
    860. 

  860. 

  861. ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2)
    862. 

  862. {
    863. 

  863. 	USE_OPLINE
    864. 

  864. 

  865. 	SAVE_OPLINE();
    866. 

  866. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    867. 

  867. 		op_1 = ZVAL_UNDEFINED_OP1();
    868. 

  868. 	}
    869. 

  869. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    870. 

  870. 		op_2 = ZVAL_UNDEFINED_OP2();
    871. 

  871. 	}
    872. 

  872. 	bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2);
    873. 

  873. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    874. 

  874. 		zval_ptr_dtor_nogc(op_1);
    875. 

  875. 	}
    876. 

  876. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    877. 

  877. 		zval_ptr_dtor_nogc(op_2);
    878. 

  878. 	}
    879. 

  879. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    880. 

  880. }
    881. 

  881. 

  882. ZEND_VM_HOT_NOCONSTCONST_HANDLER(11, ZEND_BW_XOR, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(COMMUTATIVE))
    883. 

  883. {
    884. 

  884. 	USE_OPLINE
    885. 

  885. 	zval *op1, *op2;
    886. 

  886. 

  887. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    888. 

  888. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    889. 

  889. 	if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
    890. 

  890. 		/* pass */
    891. 

  891. 	} else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
    892. 

  892. 			&& EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
    893. 

  893. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
    894. 

  894. 		ZEND_VM_NEXT_OPCODE();
    895. 

  895. 	}
    896. 

  896. 

  897. 	ZEND_VM_DISPATCH_TO_HELPER(zend_bw_xor_helper, op_1, op1, op_2, op2);
    898. 

  898. }
    899. 

  899. 

  900. ZEND_VM_COLD_CONSTCONST_HANDLER(15, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(COMMUTATIVE))
    901. 

  901. {
    902. 

  902. 	USE_OPLINE
    903. 

  903. 	zval *op1, *op2;
    904. 

  904. 

  905. 	SAVE_OPLINE();
    906. 

  906. 	op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
    907. 

  907. 	op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
    908. 

  908. 	boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
    909. 

  909. 	FREE_OP1();
    910. 

  910. 	FREE_OP2();
    911. 

  911. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    912. 

  912. }
    913. 

  913. 

  914. ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1)
    915. 

  915. {
    916. 

  916. 	USE_OPLINE
    917. 

  917. 

  918. 	SAVE_OPLINE();
    919. 

  919. 	if (UNEXPECTED(Z_TYPE_P(op_1) == IS_UNDEF)) {
    920. 

  920. 		op_1 = ZVAL_UNDEFINED_OP1();
    921. 

  921. 	}
    922. 

  922. 	bitwise_not_function(EX_VAR(opline->result.var), op_1);
    923. 

  923. 	FREE_OP1();
    924. 

  924. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    925. 

  925. }
    926. 

  926. 

  927. ZEND_VM_HOT_NOCONST_HANDLER(13, ZEND_BW_NOT, CONST|TMPVARCV, ANY)
    928. 

  928. {
    929. 

  929. 	USE_OPLINE
    930. 

  930. 	zval *op1;
    931. 

  931. 

  932. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    933. 

  933. 	if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
    934. 

  934. 		ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
    935. 

  935. 		ZEND_VM_NEXT_OPCODE();
    936. 

  936. 	}
    937. 

  937. 

  938. 	ZEND_VM_DISPATCH_TO_HELPER(zend_bw_not_helper, op_1, op1);
    939. 

  939. }
    940. 

  940. 

  941. ZEND_VM_COLD_CONST_HANDLER(14, ZEND_BOOL_NOT, CONST|TMPVAR|CV, ANY)
    942. 

  942. {
    943. 

  943. 	USE_OPLINE
    944. 

  944. 	zval *val;
    945. 

  945. 

  946. 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    947. 

  947. 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
    948. 

  948. 		ZVAL_FALSE(EX_VAR(opline->result.var));
    949. 

  949. 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
    950. 

  950. 		/* The result and op1 can be the same cv zval */
    951. 

  951. 		const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
    952. 

  952. 		ZVAL_TRUE(EX_VAR(opline->result.var));
    953. 

  953. 		if (OP1_TYPE == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
    954. 

  954. 			SAVE_OPLINE();
    955. 

  955. 			ZVAL_UNDEFINED_OP1();
    956. 

  956. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    957. 

  957. 		}
    958. 

  958. 	} else {
    959. 

  959. 		SAVE_OPLINE();
    960. 

  960. 		ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
    961. 

  961. 		FREE_OP1();
    962. 

  962. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    963. 

  963. 	}
    964. 

  964. 	ZEND_VM_NEXT_OPCODE();
    965. 

  965. }
    966. 

  966. 

  967. ZEND_VM_COLD_HELPER(zend_this_not_in_object_context_helper, ANY, ANY)
    968. 

  968. {
    969. 

  969. 	USE_OPLINE
    970. 

  970. 

  971. 	SAVE_OPLINE();
    972. 

  972. 	zend_throw_error(NULL, "Using $this when not in object context");
    973. 

  973. 	UNDEF_RESULT();
    974. 

  974. 	HANDLE_EXCEPTION();
    975. 

  975. }
    976. 

  976. 

  977. ZEND_VM_COLD_HELPER(zend_undefined_function_helper, ANY, ANY)
    978. 

  978. {
    979. 

  979. 	USE_OPLINE
    980. 

  980. 	zval *function_name;
    981. 

  981. 

  982. 	SAVE_OPLINE();
    983. 

  983. 	function_name = RT_CONSTANT(opline, opline->op2);
    984. 

  984. 	zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name));
    985. 

  985. 	HANDLE_EXCEPTION();
    986. 

  986. }
    987. 

  987. 

  988. ZEND_VM_HANDLER(28, ZEND_ASSIGN_OBJ_OP, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, OP)
    989. 

  989. {
    990. 

  990. 	USE_OPLINE
    991. 

  991. 	zval *object;
    992. 

  992. 	zval *property;
    993. 

  993. 	zval *value;
    994. 

  994. 	zval *zptr;
    995. 

  995. 	void **cache_slot;
    996. 

  996. 	zend_property_info *prop_info;
    997. 

  997. 	zend_object *zobj;
    998. 

  998. 	zend_string *name, *tmp_name;
    999. 

  999. 

  1000. 	SAVE_OPLINE();
    1001. 

  1001. 	object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1002. 

  1002. 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
    1003. 

  1003. 

  1004. 	do {
    1005. 

  1005. 		value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
    1006. 

  1006. 

  1007. 		if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
    1008. 

  1008. 			if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
    1009. 

  1009. 				object = Z_REFVAL_P(object);
    1010. 

  1010. 				ZEND_VM_C_GOTO(assign_op_object);
    1011. 

  1011. 			}
    1012. 

  1012. 			if (OP1_TYPE == IS_CV
    1013. 

  1013. 			 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
    1014. 

  1014. 				ZVAL_UNDEFINED_OP1();
    1015. 

  1015. 			}
    1016. 

  1016. 			zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
    1017. 

  1017. 			break;
    1018. 

  1018. 		}
    1019. 

  1019. 

  1020. ZEND_VM_C_LABEL(assign_op_object):
    1021. 

  1021. 		/* here we are sure we are dealing with an object */
    1022. 

  1022. 		zobj = Z_OBJ_P(object);
    1023. 

  1023. 		if (OP2_TYPE == IS_CONST) {
    1024. 

  1024. 			name = Z_STR_P(property);
    1025. 

  1025. 		} else {
    1026. 

  1026. 			name = zval_try_get_tmp_string(property, &tmp_name);
    1027. 

  1027. 			if (UNEXPECTED(!name)) {
    1028. 

  1028. 				UNDEF_RESULT();
    1029. 

  1029. 				break;
    1030. 

  1030. 			}
    1031. 

  1031. 		}
    1032. 

  1032. 		cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
    1033. 

  1033. 		if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
    1034. 

  1034. 			if (UNEXPECTED(Z_ISERROR_P(zptr))) {
    1035. 

  1035. 				if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1036. 

  1036. 					ZVAL_NULL(EX_VAR(opline->result.var));
    1037. 

  1037. 				}
    1038. 

  1038. 			} else {
    1039. 

  1039. 				zval *orig_zptr = zptr;
    1040. 

  1040. 				zend_reference *ref;
    1041. 

  1041. 

  1042. 				do {
    1043. 

  1043. 					if (UNEXPECTED(Z_ISREF_P(zptr))) {
    1044. 

  1044. 						ref = Z_REF_P(zptr);
    1045. 

  1045. 						zptr = Z_REFVAL_P(zptr);
    1046. 

  1046. 						if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
    1047. 

  1047. 							zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
    1048. 

  1048. 							break;
    1049. 

  1049. 						}
    1050. 

  1050. 					}
    1051. 

  1051. 

  1052. 					if (OP2_TYPE == IS_CONST) {
    1053. 

  1053. 						prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
    1054. 

  1054. 					} else {
    1055. 

  1055. 						prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
    1056. 

  1056. 					}
    1057. 

  1057. 					if (UNEXPECTED(prop_info)) {
    1058. 

  1058. 						/* special case for typed properties */
    1059. 

  1059. 						zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
    1060. 

  1060. 					} else {
    1061. 

  1061. 						zend_binary_op(zptr, zptr, value OPLINE_CC);
    1062. 

  1062. 					}
    1063. 

  1063. 				} while (0);
    1064. 

  1064. 

  1065. 				if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1066. 

  1066. 					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
    1067. 

  1067. 				}
    1068. 

  1068. 			}
    1069. 

  1069. 		} else {
    1070. 

  1070. 			zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
    1071. 

  1071. 		}
    1072. 

  1072. 		if (OP2_TYPE != IS_CONST) {
    1073. 

  1073. 			zend_tmp_string_release(tmp_name);
    1074. 

  1074. 		}
    1075. 

  1075. 	} while (0);
    1076. 

  1076. 

  1077. 	FREE_OP_DATA();
    1078. 

  1078. 	FREE_OP2();
    1079. 

  1079. 	FREE_OP1_VAR_PTR();
    1080. 

  1080. 	/* assign_obj has two opcodes! */
    1081. 

  1081. 	ZEND_VM_NEXT_OPCODE_EX(1, 2);
    1082. 

  1082. }
    1083. 

  1083. 

  1084. /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
    1085. 

  1085. ZEND_VM_HANDLER(29, ZEND_ASSIGN_STATIC_PROP_OP, ANY, ANY, OP)
    1086. 

  1086. {
    1087. 

  1087. 	/* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
    1088. 

  1088. 

  1089. 	USE_OPLINE
    1090. 

  1090. 	zval *prop, *value;
    1091. 

  1091. 	zend_property_info *prop_info;
    1092. 

  1092. 	zend_reference *ref;
    1093. 

  1093. 

  1094. 	SAVE_OPLINE();
    1095. 

  1095. 

  1096. 	if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
    1097. 

  1097. 		ZEND_ASSERT(EG(exception));
    1098. 

  1098. 		UNDEF_RESULT();
    1099. 

  1099. 		FREE_UNFETCHED_OP_DATA();
    1100. 

  1100. 		HANDLE_EXCEPTION();
    1101. 

  1101. 	}
    1102. 

  1102. 

  1103. 	value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
    1104. 

  1104. 

  1105. 	do {
    1106. 

  1106. 		if (UNEXPECTED(Z_ISREF_P(prop))) {
    1107. 

  1107. 			ref = Z_REF_P(prop);
    1108. 

  1108. 			prop = Z_REFVAL_P(prop);
    1109. 

  1109. 			if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
    1110. 

  1110. 				zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
    1111. 

  1111. 				break;
    1112. 

  1112. 			}
    1113. 

  1113. 		}
    1114. 

  1114. 

  1115. 		if (UNEXPECTED(ZEND_TYPE_IS_SET(prop_info->type))) {
    1116. 

  1116. 			/* special case for typed properties */
    1117. 

  1117. 			zend_binary_assign_op_typed_prop(prop_info, prop, value OPLINE_CC EXECUTE_DATA_CC);
    1118. 

  1118. 		} else {
    1119. 

  1119. 			zend_binary_op(prop, prop, value OPLINE_CC);
    1120. 

  1120. 		}
    1121. 

  1121. 	} while (0);
    1122. 

  1122. 

  1123. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1124. 

  1124. 		ZVAL_COPY(EX_VAR(opline->result.var), prop);
    1125. 

  1125. 	}
    1126. 

  1126. 

  1127. 	FREE_OP_DATA();
    1128. 

  1128. 	/* assign_static_prop has two opcodes! */
    1129. 

  1129. 	ZEND_VM_NEXT_OPCODE_EX(1, 2);
    1130. 

  1130. }
    1131. 

  1131. 

  1132. ZEND_VM_HANDLER(27, ZEND_ASSIGN_DIM_OP, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, OP)
    1133. 

  1133. {
    1134. 

  1134. 	USE_OPLINE
    1135. 

  1135. 	zval *var_ptr;
    1136. 

  1136. 	zval *value, *container, *dim;
    1137. 

  1137. 

  1138. 	SAVE_OPLINE();
    1139. 

  1139. 	container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1140. 

  1140. 

  1141. 	if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    1142. 

  1142. ZEND_VM_C_LABEL(assign_dim_op_array):
    1143. 

  1143. 		SEPARATE_ARRAY(container);
    1144. 

  1144. ZEND_VM_C_LABEL(assign_dim_op_new_array):
    1145. 

  1145. 		dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    1146. 

  1146. 		if (OP2_TYPE == IS_UNUSED) {
    1147. 

  1147. 			var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval));
    1148. 

  1148. 			if (UNEXPECTED(!var_ptr)) {
    1149. 

  1149. 				zend_cannot_add_element();
    1150. 

  1150. 				ZEND_VM_C_GOTO(assign_dim_op_ret_null);
    1151. 

  1151. 			}
    1152. 

  1152. 		} else {
    1153. 

  1153. 			if (OP2_TYPE == IS_CONST) {
    1154. 

  1154. 				var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
    1155. 

  1155. 			} else {
    1156. 

  1156. 				var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
    1157. 

  1157. 			}
    1158. 

  1158. 			if (UNEXPECTED(!var_ptr)) {
    1159. 

  1159. 				ZEND_VM_C_GOTO(assign_dim_op_ret_null);
    1160. 

  1160. 			}
    1161. 

  1161. 		}
    1162. 

  1162. 

  1163. 		value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
    1164. 

  1164. 

  1165. 		do {
    1166. 

  1166. 			if (OP2_TYPE != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
    1167. 

  1167. 				zend_reference *ref = Z_REF_P(var_ptr);
    1168. 

  1168. 				var_ptr = Z_REFVAL_P(var_ptr);
    1169. 

  1169. 				if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
    1170. 

  1170. 					zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
    1171. 

  1171. 					break;
    1172. 

  1172. 				}
    1173. 

  1173. 			}
    1174. 

  1174. 			zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
    1175. 

  1175. 		} while (0);
    1176. 

  1176. 

  1177. 		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1178. 

  1178. 			ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
    1179. 

  1179. 		}
    1180. 

  1180. 		FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
    1181. 

  1181. 	} else {
    1182. 

  1182. 		if (EXPECTED(Z_ISREF_P(container))) {
    1183. 

  1183. 			container = Z_REFVAL_P(container);
    1184. 

  1184. 			if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    1185. 

  1185. 				ZEND_VM_C_GOTO(assign_dim_op_array);
    1186. 

  1186. 			}
    1187. 

  1187. 		}
    1188. 

  1188. 

  1189. 		dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
    1190. 

  1190. 

  1191. 		if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
    1192. 

  1192. 			if (OP2_TYPE == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
    1193. 

  1193. 				dim++;
    1194. 

  1194. 			}
    1195. 

  1195. 			zend_binary_assign_op_obj_dim(container, dim OPLINE_CC EXECUTE_DATA_CC);
    1196. 

  1196. 		} else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
    1197. 

  1197. 			if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
    1198. 

  1198. 				ZVAL_UNDEFINED_OP1();
    1199. 

  1199. 			}
    1200. 

  1200. 			ZVAL_ARR(container, zend_new_array(8));
    1201. 

  1201. 			ZEND_VM_C_GOTO(assign_dim_op_new_array);
    1202. 

  1202. 		} else {
    1203. 

  1203. 			zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
    1204. 

  1204. ZEND_VM_C_LABEL(assign_dim_op_ret_null):
    1205. 

  1205. 			if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1206. 

  1206. 				ZVAL_NULL(EX_VAR(opline->result.var));
    1207. 

  1207. 			}
    1208. 

  1208. 		}
    1209. 

  1209. 	}
    1210. 

  1210. 

  1211. 	FREE_OP2();
    1212. 

  1212. 	FREE_OP1_VAR_PTR();
    1213. 

  1213. 	ZEND_VM_NEXT_OPCODE_EX(1, 2);
    1214. 

  1214. }
    1215. 

  1215. 

  1216. ZEND_VM_HANDLER(26, ZEND_ASSIGN_OP, VAR|CV, CONST|TMPVAR|CV, OP)
    1217. 

  1217. {
    1218. 

  1218. 	USE_OPLINE
    1219. 

  1219. 	zval *var_ptr;
    1220. 

  1220. 	zval *value;
    1221. 

  1221. 

  1222. 	SAVE_OPLINE();
    1223. 

  1223. 	value = GET_OP2_ZVAL_PTR(BP_VAR_R);
    1224. 

  1224. 	var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
    1225. 

  1225. 

  1226. 	do {
    1227. 

  1227. 		if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
    1228. 

  1228. 			zend_reference *ref = Z_REF_P(var_ptr);
    1229. 

  1229. 			var_ptr = Z_REFVAL_P(var_ptr);
    1230. 

  1230. 			if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
    1231. 

  1231. 				zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
    1232. 

  1232. 				break;
    1233. 

  1233. 			}
    1234. 

  1234. 		}
    1235. 

  1235. 		zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
    1236. 

  1236. 	} while (0);
    1237. 

  1237. 

  1238. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1239. 

  1239. 		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
    1240. 

  1240. 	}
    1241. 

  1241. 

  1242. 	FREE_OP2();
    1243. 

  1243. 	FREE_OP1_VAR_PTR();
    1244. 

  1244. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1245. 

  1245. }
    1246. 

  1246. 

  1247. ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    1248. 

  1248. {
    1249. 

  1249. 	USE_OPLINE
    1250. 

  1250. 	zval *object;
    1251. 

  1251. 	zval *property;
    1252. 

  1252. 	zval *zptr;
    1253. 

  1253. 	void **cache_slot;
    1254. 

  1254. 	zend_property_info *prop_info;
    1255. 

  1255. 	zend_object *zobj;
    1256. 

  1256. 	zend_string *name, *tmp_name;
    1257. 

  1257. 

  1258. 	SAVE_OPLINE();
    1259. 

  1259. 	object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1260. 

  1260. 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
    1261. 

  1261. 

  1262. 	do {
    1263. 

  1263. 		if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
    1264. 

  1264. 			if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
    1265. 

  1265. 				object = Z_REFVAL_P(object);
    1266. 

  1266. 				ZEND_VM_C_GOTO(pre_incdec_object);
    1267. 

  1267. 			}
    1268. 

  1268. 			if (OP1_TYPE == IS_CV
    1269. 

  1269. 			 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
    1270. 

  1270. 				ZVAL_UNDEFINED_OP1();
    1271. 

  1271. 			}
    1272. 

  1272. 			zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
    1273. 

  1273. 			break;
    1274. 

  1274. 		}
    1275. 

  1275. 

  1276. ZEND_VM_C_LABEL(pre_incdec_object):
    1277. 

  1277. 		/* here we are sure we are dealing with an object */
    1278. 

  1278. 		zobj = Z_OBJ_P(object);
    1279. 

  1279. 		if (OP2_TYPE == IS_CONST) {
    1280. 

  1280. 			name = Z_STR_P(property);
    1281. 

  1281. 		} else {
    1282. 

  1282. 			name = zval_try_get_tmp_string(property, &tmp_name);
    1283. 

  1283. 			if (UNEXPECTED(!name)) {
    1284. 

  1284. 				UNDEF_RESULT();
    1285. 

  1285. 				break;
    1286. 

  1286. 			}
    1287. 

  1287. 		}
    1288. 

  1288. 		cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
    1289. 

  1289. 		if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
    1290. 

  1290. 			if (UNEXPECTED(Z_ISERROR_P(zptr))) {
    1291. 

  1291. 				if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1292. 

  1292. 					ZVAL_NULL(EX_VAR(opline->result.var));
    1293. 

  1293. 				}
    1294. 

  1294. 			} else {
    1295. 

  1295. 				if (OP2_TYPE == IS_CONST) {
    1296. 

  1296. 					prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
    1297. 

  1297. 				} else {
    1298. 

  1298. 					prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
    1299. 

  1299. 				}
    1300. 

  1300. 				zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
    1301. 

  1301. 			}
    1302. 

  1302. 		} else {
    1303. 

  1303. 			zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
    1304. 

  1304. 		}
    1305. 

  1305. 		if (OP2_TYPE != IS_CONST) {
    1306. 

  1306. 			zend_tmp_string_release(tmp_name);
    1307. 

  1307. 		}
    1308. 

  1308. 	} while (0);
    1309. 

  1309. 

  1310. 	FREE_OP2();
    1311. 

  1311. 	FREE_OP1_VAR_PTR();
    1312. 

  1312. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1313. 

  1313. }
    1314. 

  1314. 

  1315. ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    1316. 

  1316. {
    1317. 

  1317. 	ZEND_VM_DISPATCH_TO_HANDLER(ZEND_PRE_INC_OBJ);
    1318. 

  1318. }
    1319. 

  1319. 

  1320. ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    1321. 

  1321. {
    1322. 

  1322. 	USE_OPLINE
    1323. 

  1323. 	zval *object;
    1324. 

  1324. 	zval *property;
    1325. 

  1325. 	zval *zptr;
    1326. 

  1326. 	void **cache_slot;
    1327. 

  1327. 	zend_property_info *prop_info;
    1328. 

  1328. 	zend_object *zobj;
    1329. 

  1329. 	zend_string *name, *tmp_name;
    1330. 

  1330. 

  1331. 	SAVE_OPLINE();
    1332. 

  1332. 	object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1333. 

  1333. 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
    1334. 

  1334. 

  1335. 	do {
    1336. 

  1336. 		if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
    1337. 

  1337. 			if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
    1338. 

  1338. 				object = Z_REFVAL_P(object);
    1339. 

  1339. 				ZEND_VM_C_GOTO(post_incdec_object);
    1340. 

  1340. 			}
    1341. 

  1341. 			if (OP1_TYPE == IS_CV
    1342. 

  1342. 			 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
    1343. 

  1343. 				ZVAL_UNDEFINED_OP1();
    1344. 

  1344. 			}
    1345. 

  1345. 			zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
    1346. 

  1346. 			break;
    1347. 

  1347. 		}
    1348. 

  1348. 

  1349. ZEND_VM_C_LABEL(post_incdec_object):
    1350. 

  1350. 		/* here we are sure we are dealing with an object */
    1351. 

  1351. 		zobj = Z_OBJ_P(object);
    1352. 

  1352. 		if (OP2_TYPE == IS_CONST) {
    1353. 

  1353. 			name = Z_STR_P(property);
    1354. 

  1354. 		} else {
    1355. 

  1355. 			name = zval_try_get_tmp_string(property, &tmp_name);
    1356. 

  1356. 			if (UNEXPECTED(!name)) {
    1357. 

  1357. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    1358. 

  1358. 				break;
    1359. 

  1359. 			}
    1360. 

  1360. 		}
    1361. 

  1361. 		cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
    1362. 

  1362. 		if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
    1363. 

  1363. 			if (UNEXPECTED(Z_ISERROR_P(zptr))) {
    1364. 

  1364. 				ZVAL_NULL(EX_VAR(opline->result.var));
    1365. 

  1365. 			} else {
    1366. 

  1366. 				if (OP2_TYPE == IS_CONST) {
    1367. 

  1367. 					prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
    1368. 

  1368. 				} else {
    1369. 

  1369. 					prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
    1370. 

  1370. 				}
    1371. 

  1371. 

  1372. 				zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
    1373. 

  1373. 			}
    1374. 

  1374. 		} else {
    1375. 

  1375. 			zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
    1376. 

  1376. 		}
    1377. 

  1377. 		if (OP2_TYPE != IS_CONST) {
    1378. 

  1378. 			zend_tmp_string_release(tmp_name);
    1379. 

  1379. 		}
    1380. 

  1380. 	} while (0);
    1381. 

  1381. 

  1382. 	FREE_OP2();
    1383. 

  1383. 	FREE_OP1_VAR_PTR();
    1384. 

  1384. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1385. 

  1385. }
    1386. 

  1386. 

  1387. ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    1388. 

  1388. {
    1389. 

  1389. 	ZEND_VM_DISPATCH_TO_HANDLER(ZEND_POST_INC_OBJ);
    1390. 

  1390. }
    1391. 

  1391. 

  1392. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
    1393. 

  1393. ZEND_VM_HANDLER(38, ZEND_PRE_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
    1394. 

  1394. {
    1395. 

  1395. 	USE_OPLINE
    1396. 

  1396. 	zval *prop;
    1397. 

  1397. 	zend_property_info *prop_info;
    1398. 

  1398. 

  1399. 	SAVE_OPLINE();
    1400. 

  1400. 

  1401. 	if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
    1402. 

  1402. 		UNDEF_RESULT();
    1403. 

  1403. 		HANDLE_EXCEPTION();
    1404. 

  1404. 	}
    1405. 

  1405. 

  1406. 	zend_pre_incdec_property_zval(prop,
    1407. 

  1407. 		ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
    1408. 

  1408. 

  1409. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1410. 

  1410. }
    1411. 

  1411. 

  1412. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
    1413. 

  1413. ZEND_VM_HANDLER(39, ZEND_PRE_DEC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
    1414. 

  1414. {
    1415. 

  1415. 	ZEND_VM_DISPATCH_TO_HANDLER(ZEND_PRE_INC_STATIC_PROP);
    1416. 

  1416. }
    1417. 

  1417. 

  1418. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
    1419. 

  1419. ZEND_VM_HANDLER(40, ZEND_POST_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
    1420. 

  1420. {
    1421. 

  1421. 	USE_OPLINE
    1422. 

  1422. 	zval *prop;
    1423. 

  1423. 	zend_property_info *prop_info;
    1424. 

  1424. 

  1425. 	SAVE_OPLINE();
    1426. 

  1426. 

  1427. 	if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
    1428. 

  1428. 		UNDEF_RESULT();
    1429. 

  1429. 		HANDLE_EXCEPTION();
    1430. 

  1430. 	}
    1431. 

  1431. 

  1432. 	zend_post_incdec_property_zval(prop,
    1433. 

  1433. 		ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
    1434. 

  1434. 

  1435. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1436. 

  1436. }
    1437. 

  1437. 

  1438. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
    1439. 

  1439. ZEND_VM_HANDLER(41, ZEND_POST_DEC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
    1440. 

  1440. {
    1441. 

  1441. 	ZEND_VM_DISPATCH_TO_HANDLER(ZEND_POST_INC_STATIC_PROP);
    1442. 

  1442. }
    1443. 

  1443. 

  1444. ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY)
    1445. 

  1445. {
    1446. 

  1446. 	USE_OPLINE
    1447. 

  1447. 	zval *var_ptr;
    1448. 

  1448. 

  1449. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1450. 

  1450. 

  1451. 	SAVE_OPLINE();
    1452. 

  1452. 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
    1453. 

  1453. 		ZVAL_NULL(var_ptr);
    1454. 

  1454. 		ZVAL_UNDEFINED_OP1();
    1455. 

  1455. 	}
    1456. 

  1456. 

  1457. 	do {
    1458. 

  1458. 		if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
    1459. 

  1459. 			zend_reference *ref = Z_REF_P(var_ptr);
    1460. 

  1460. 			var_ptr = Z_REFVAL_P(var_ptr);
    1461. 

  1461. 			if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
    1462. 

  1462. 				zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
    1463. 

  1463. 				break;
    1464. 

  1464. 			}
    1465. 

  1465. 		}
    1466. 

  1466. 		increment_function(var_ptr);
    1467. 

  1467. 	} while (0);
    1468. 

  1468. 

  1469. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1470. 

  1470. 		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
    1471. 

  1471. 	}
    1472. 

  1472. 

  1473. 	FREE_OP1_VAR_PTR();
    1474. 

  1474. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1475. 

  1475. }
    1476. 

  1476. 

  1477. ZEND_VM_HOT_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL))
    1478. 

  1478. {
    1479. 

  1479. 	USE_OPLINE
    1480. 

  1480. 	zval *var_ptr;
    1481. 

  1481. 

  1482. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1483. 

  1483. 

  1484. 	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
    1485. 

  1485. 		fast_long_increment_function(var_ptr);
    1486. 

  1486. 		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1487. 

  1487. 			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
    1488. 

  1488. 		}
    1489. 

  1489. 		ZEND_VM_NEXT_OPCODE();
    1490. 

  1490. 	}
    1491. 

  1491. 

  1492. 	ZEND_VM_DISPATCH_TO_HELPER(zend_pre_inc_helper);
    1493. 

  1493. }
    1494. 

  1494. 

  1495. ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY)
    1496. 

  1496. {
    1497. 

  1497. 	USE_OPLINE
    1498. 

  1498. 	zval *var_ptr;
    1499. 

  1499. 

  1500. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1501. 

  1501. 

  1502. 	SAVE_OPLINE();
    1503. 

  1503. 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
    1504. 

  1504. 		ZVAL_NULL(var_ptr);
    1505. 

  1505. 		ZVAL_UNDEFINED_OP1();
    1506. 

  1506. 	}
    1507. 

  1507. 

  1508. 	do {
    1509. 

  1509. 		if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
    1510. 

  1510. 			zend_reference *ref = Z_REF_P(var_ptr);
    1511. 

  1511. 			var_ptr = Z_REFVAL_P(var_ptr);
    1512. 

  1512. 

  1513. 			if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
    1514. 

  1514. 				zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
    1515. 

  1515. 				break;
    1516. 

  1516. 			}
    1517. 

  1517. 		}
    1518. 

  1518. 		decrement_function(var_ptr);
    1519. 

  1519. 	} while (0);
    1520. 

  1520. 

  1521. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1522. 

  1522. 		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
    1523. 

  1523. 	}
    1524. 

  1524. 

  1525. 	FREE_OP1_VAR_PTR();
    1526. 

  1526. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1527. 

  1527. }
    1528. 

  1528. 

  1529. ZEND_VM_HOT_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL))
    1530. 

  1530. {
    1531. 

  1531. 	USE_OPLINE
    1532. 

  1532. 	zval *var_ptr;
    1533. 

  1533. 

  1534. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1535. 

  1535. 

  1536. 	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
    1537. 

  1537. 		fast_long_decrement_function(var_ptr);
    1538. 

  1538. 		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    1539. 

  1539. 			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
    1540. 

  1540. 		}
    1541. 

  1541. 		ZEND_VM_NEXT_OPCODE();
    1542. 

  1542. 	}
    1543. 

  1543. 

  1544. 	ZEND_VM_DISPATCH_TO_HELPER(zend_pre_dec_helper);
    1545. 

  1545. }
    1546. 

  1546. 

  1547. ZEND_VM_HELPER(zend_post_inc_helper, VAR|CV, ANY)
    1548. 

  1548. {
    1549. 

  1549. 	USE_OPLINE
    1550. 

  1550. 	zval *var_ptr;
    1551. 

  1551. 

  1552. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1553. 

  1553. 

  1554. 	SAVE_OPLINE();
    1555. 

  1555. 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
    1556. 

  1556. 		ZVAL_NULL(var_ptr);
    1557. 

  1557. 		ZVAL_UNDEFINED_OP1();
    1558. 

  1558. 	}
    1559. 

  1559. 

  1560. 	do {
    1561. 

  1561. 		if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
    1562. 

  1562. 			zend_reference *ref = Z_REF_P(var_ptr);
    1563. 

  1563. 			var_ptr = Z_REFVAL_P(var_ptr);
    1564. 

  1564. 

  1565. 			if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
    1566. 

  1566. 				zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
    1567. 

  1567. 				break;
    1568. 

  1568. 			}
    1569. 

  1569. 		}
    1570. 

  1570. 		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
    1571. 

  1571. 

  1572. 		increment_function(var_ptr);
    1573. 

  1573. 	} while (0);
    1574. 

  1574. 

  1575. 	FREE_OP1_VAR_PTR();
    1576. 

  1576. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1577. 

  1577. }
    1578. 

  1578. 

  1579. ZEND_VM_HOT_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
    1580. 

  1580. {
    1581. 

  1581. 	USE_OPLINE
    1582. 

  1582. 	zval *var_ptr;
    1583. 

  1583. 

  1584. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1585. 

  1585. 

  1586. 	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
    1587. 

  1587. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
    1588. 

  1588. 		fast_long_increment_function(var_ptr);
    1589. 

  1589. 		ZEND_VM_NEXT_OPCODE();
    1590. 

  1590. 	}
    1591. 

  1591. 

  1592. 	ZEND_VM_DISPATCH_TO_HELPER(zend_post_inc_helper);
    1593. 

  1593. }
    1594. 

  1594. 

  1595. ZEND_VM_HELPER(zend_post_dec_helper, VAR|CV, ANY)
    1596. 

  1596. {
    1597. 

  1597. 	USE_OPLINE
    1598. 

  1598. 	zval *var_ptr;
    1599. 

  1599. 

  1600. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1601. 

  1601. 

  1602. 	SAVE_OPLINE();
    1603. 

  1603. 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
    1604. 

  1604. 		ZVAL_NULL(var_ptr);
    1605. 

  1605. 		ZVAL_UNDEFINED_OP1();
    1606. 

  1606. 	}
    1607. 

  1607. 

  1608. 	do {
    1609. 

  1609. 		if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
    1610. 

  1610. 			zend_reference *ref = Z_REF_P(var_ptr);
    1611. 

  1611. 			var_ptr = Z_REFVAL_P(var_ptr);
    1612. 

  1612. 

  1613. 			if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
    1614. 

  1614. 				zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
    1615. 

  1615. 				break;
    1616. 

  1616. 			}
    1617. 

  1617. 		}
    1618. 

  1618. 		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
    1619. 

  1619. 

  1620. 		decrement_function(var_ptr);
    1621. 

  1621. 	} while (0);
    1622. 

  1622. 

  1623. 	FREE_OP1_VAR_PTR();
    1624. 

  1624. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1625. 

  1625. }
    1626. 

  1626. 

  1627. ZEND_VM_HOT_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
    1628. 

  1628. {
    1629. 

  1629. 	USE_OPLINE
    1630. 

  1630. 	zval *var_ptr;
    1631. 

  1631. 

  1632. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1633. 

  1633. 

  1634. 	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
    1635. 

  1635. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
    1636. 

  1636. 		fast_long_decrement_function(var_ptr);
    1637. 

  1637. 		ZEND_VM_NEXT_OPCODE();
    1638. 

  1638. 	}
    1639. 

  1639. 

  1640. 	ZEND_VM_DISPATCH_TO_HELPER(zend_post_dec_helper);
    1641. 

  1641. }
    1642. 

  1642. 

  1643. ZEND_VM_HANDLER(136, ZEND_ECHO, CONST|TMPVAR|CV, ANY)
    1644. 

  1644. {
    1645. 

  1645. 	USE_OPLINE
    1646. 

  1646. 	zval *z;
    1647. 

  1647. 

  1648. 	SAVE_OPLINE();
    1649. 

  1649. 	z = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    1650. 

  1650. 

  1651. 	if (Z_TYPE_P(z) == IS_STRING) {
    1652. 

  1652. 		zend_string *str = Z_STR_P(z);
    1653. 

  1653. 

  1654. 		if (ZSTR_LEN(str) != 0) {
    1655. 

  1655. 			zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
    1656. 

  1656. 		}
    1657. 

  1657. 	} else {
    1658. 

  1658. 		zend_string *str = zval_get_string_func(z);
    1659. 

  1659. 

  1660. 		if (ZSTR_LEN(str) != 0) {
    1661. 

  1661. 			zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
    1662. 

  1662. 		} else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
    1663. 

  1663. 			ZVAL_UNDEFINED_OP1();
    1664. 

  1664. 		}
    1665. 

  1665. 		zend_string_release_ex(str, 0);
    1666. 

  1666. 	}
    1667. 

  1667. 

  1668. 	FREE_OP1();
    1669. 

  1669. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1670. 

  1670. }
    1671. 

  1671. 

  1672. ZEND_VM_HELPER(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED, int type)
    1673. 

  1673. {
    1674. 

  1674. 	USE_OPLINE
    1675. 

  1675. 	zval *varname;
    1676. 

  1676. 	zval *retval;
    1677. 

  1677. 	zend_string *name, *tmp_name;
    1678. 

  1678. 	HashTable *target_symbol_table;
    1679. 

  1679. 

  1680. 	SAVE_OPLINE();
    1681. 

  1681. 	varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    1682. 

  1682. 

  1683. 	if (OP1_TYPE == IS_CONST) {
    1684. 

  1684. 		name = Z_STR_P(varname);
    1685. 

  1685. 	} else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
    1686. 

  1686. 		name = Z_STR_P(varname);
    1687. 

  1687. 		tmp_name = NULL;
    1688. 

  1688. 	} else {
    1689. 

  1689. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
    1690. 

  1690. 			ZVAL_UNDEFINED_OP1();
    1691. 

  1691. 		}
    1692. 

  1692. 		name = zval_try_get_tmp_string(varname, &tmp_name);
    1693. 

  1693. 		if (UNEXPECTED(!name)) {
    1694. 

  1694. 			FREE_OP1();
    1695. 

  1695. 			ZVAL_UNDEF(EX_VAR(opline->result.var));
    1696. 

  1696. 			HANDLE_EXCEPTION();
    1697. 

  1697. 		}
    1698. 

  1698. 	}
    1699. 

  1699. 

  1700. 	target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
    1701. 

  1701. 	retval = zend_hash_find_ex(target_symbol_table, name, OP1_TYPE == IS_CONST);
    1702. 

  1702. 	if (retval == NULL) {
    1703. 

  1703. 		if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
    1704. 

  1704. ZEND_VM_C_LABEL(fetch_this):
    1705. 

  1705. 			zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
    1706. 

  1706. 			if (OP1_TYPE != IS_CONST) {
    1707. 

  1707. 				zend_tmp_string_release(tmp_name);
    1708. 

  1708. 			}
    1709. 

  1709. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1710. 

  1710. 		}
    1711. 

  1711. 		if (type == BP_VAR_W) {
    1712. 

  1712. 			retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
    1713. 

  1713. 		} else if (type == BP_VAR_IS) {
    1714. 

  1714. 			retval = &EG(uninitialized_zval);
    1715. 

  1715. 		} else {
    1716. 

  1716. 			zend_error(E_WARNING, "Undefined variable $%s", ZSTR_VAL(name));
    1717. 

  1717. 			if (type == BP_VAR_RW) {
    1718. 

  1718. 				retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
    1719. 

  1719. 			} else {
    1720. 

  1720. 				retval = &EG(uninitialized_zval);
    1721. 

  1721. 			}
    1722. 

  1722. 		}
    1723. 

  1723. 	/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
    1724. 

  1724. 	} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
    1725. 

  1725. 		retval = Z_INDIRECT_P(retval);
    1726. 

  1726. 		if (Z_TYPE_P(retval) == IS_UNDEF) {
    1727. 

  1727. 			if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
    1728. 

  1728. 				ZEND_VM_C_GOTO(fetch_this);
    1729. 

  1729. 			}
    1730. 

  1730. 			if (type == BP_VAR_W) {
    1731. 

  1731. 				ZVAL_NULL(retval);
    1732. 

  1732. 			} else if (type == BP_VAR_IS) {
    1733. 

  1733. 				retval = &EG(uninitialized_zval);
    1734. 

  1734. 			} else {
    1735. 

  1735. 				zend_error(E_WARNING, "Undefined variable $%s", ZSTR_VAL(name));
    1736. 

  1736. 				if (type == BP_VAR_RW) {
    1737. 

  1737. 					ZVAL_NULL(retval);
    1738. 

  1738. 				} else {
    1739. 

  1739. 					retval = &EG(uninitialized_zval);
    1740. 

  1740. 				}
    1741. 

  1741. 			}
    1742. 

  1742. 		}
    1743. 

  1743. 	}
    1744. 

  1744. 

  1745. 	if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
    1746. 

  1746. 		FREE_OP1();
    1747. 

  1747. 	}
    1748. 

  1748. 

  1749. 	if (OP1_TYPE != IS_CONST) {
    1750. 

  1750. 		zend_tmp_string_release(tmp_name);
    1751. 

  1751. 	}
    1752. 

  1752. 

  1753. 	ZEND_ASSERT(retval != NULL);
    1754. 

  1754. 	if (type == BP_VAR_R || type == BP_VAR_IS) {
    1755. 

  1755. 		ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
    1756. 

  1756. 	} else {
    1757. 

  1757. 		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
    1758. 

  1758. 	}
    1759. 

  1759. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1760. 

  1760. }
    1761. 

  1761. 

  1762. ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
    1763. 

  1763. {
    1764. 

  1764. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_R);
    1765. 

  1765. }
    1766. 

  1766. 

  1767. ZEND_VM_HANDLER(83, ZEND_FETCH_W, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
    1768. 

  1768. {
    1769. 

  1769. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_W);
    1770. 

  1770. }
    1771. 

  1771. 

  1772. ZEND_VM_HANDLER(86, ZEND_FETCH_RW, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
    1773. 

  1773. {
    1774. 

  1774. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_RW);
    1775. 

  1775. }
    1776. 

  1776. 

  1777. ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
    1778. 

  1778. {
    1779. 

  1779. 	int fetch_type =
    1780. 

  1780. 		(UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
    1781. 

  1781. 			BP_VAR_W : BP_VAR_R;
    1782. 

  1782. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, fetch_type);
    1783. 

  1783. }
    1784. 

  1784. 

  1785. ZEND_VM_HANDLER(95, ZEND_FETCH_UNSET, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
    1786. 

  1786. {
    1787. 

  1787. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_UNSET);
    1788. 

  1788. }
    1789. 

  1789. 

  1790. ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
    1791. 

  1791. {
    1792. 

  1792. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_IS);
    1793. 

  1793. }
    1794. 

  1794. 

  1795. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
    1796. 

  1796. ZEND_VM_HELPER(zend_fetch_static_prop_helper, ANY, ANY, int type)
    1797. 

  1797. {
    1798. 

  1798. 	USE_OPLINE
    1799. 

  1799. 	zval *prop;
    1800. 

  1800. 

  1801. 	SAVE_OPLINE();
    1802. 

  1802. 

  1803. 	if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
    1804. 

  1804. 		ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS));
    1805. 

  1805. 		prop = &EG(uninitialized_zval);
    1806. 

  1806. 	}
    1807. 

  1807. 

  1808. 	if (type == BP_VAR_R || type == BP_VAR_IS) {
    1809. 

  1809. 		ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
    1810. 

  1810. 	} else {
    1811. 

  1811. 		ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
    1812. 

  1812. 	}
    1813. 

  1813. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1814. 

  1814. }
    1815. 

  1815. 

  1816. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
    1817. 

  1817. ZEND_VM_HANDLER(173, ZEND_FETCH_STATIC_PROP_R, ANY, CLASS_FETCH, CACHE_SLOT)
    1818. 

  1818. {
    1819. 

  1819. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_R);
    1820. 

  1820. }
    1821. 

  1821. 

  1822. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
    1823. 

  1823. ZEND_VM_HANDLER(174, ZEND_FETCH_STATIC_PROP_W, ANY, CLASS_FETCH, FETCH_REF|DIM_WRITE|CACHE_SLOT)
    1824. 

  1824. {
    1825. 

  1825. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_W);
    1826. 

  1826. }
    1827. 

  1827. 

  1828. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
    1829. 

  1829. ZEND_VM_HANDLER(175, ZEND_FETCH_STATIC_PROP_RW, ANY, CLASS_FETCH, CACHE_SLOT)
    1830. 

  1830. {
    1831. 

  1831. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_RW);
    1832. 

  1832. }
    1833. 

  1833. 

  1834. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
    1835. 

  1835. ZEND_VM_HANDLER(177, ZEND_FETCH_STATIC_PROP_FUNC_ARG, ANY, CLASS_FETCH, FETCH_REF|CACHE_SLOT)
    1836. 

  1836. {
    1837. 

  1837. 	int fetch_type =
    1838. 

  1838. 		(UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
    1839. 

  1839. 			BP_VAR_W : BP_VAR_R;
    1840. 

  1840. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, fetch_type);
    1841. 

  1841. }
    1842. 

  1842. 

  1843. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
    1844. 

  1844. ZEND_VM_HANDLER(178, ZEND_FETCH_STATIC_PROP_UNSET, ANY, CLASS_FETCH, CACHE_SLOT)
    1845. 

  1845. {
    1846. 

  1846. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_UNSET);
    1847. 

  1847. }
    1848. 

  1848. 

  1849. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
    1850. 

  1850. ZEND_VM_HANDLER(176, ZEND_FETCH_STATIC_PROP_IS, ANY, CLASS_FETCH, CACHE_SLOT)
    1851. 

  1851. {
    1852. 

  1852. 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_IS);
    1853. 

  1853. }
    1854. 

  1854. 

  1855. ZEND_VM_COLD_CONSTCONST_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
    1856. 

  1856. {
    1857. 

  1857. 	USE_OPLINE
    1858. 

  1858. 	zval *container, *dim, *value;
    1859. 

  1859. 

  1860. 	SAVE_OPLINE();
    1861. 

  1861. 	container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    1862. 

  1862. 	dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    1863. 

  1863. 	if (OP1_TYPE != IS_CONST) {
    1864. 

  1864. 		if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    1865. 

  1865. ZEND_VM_C_LABEL(fetch_dim_r_array):
    1866. 

  1866. 			value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, OP2_TYPE, BP_VAR_R EXECUTE_DATA_CC);
    1867. 

  1867. 			ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
    1868. 

  1868. 		} else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
    1869. 

  1869. 			container = Z_REFVAL_P(container);
    1870. 

  1870. 			if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    1871. 

  1871. 				ZEND_VM_C_GOTO(fetch_dim_r_array);
    1872. 

  1872. 			} else {
    1873. 

  1873. 				ZEND_VM_C_GOTO(fetch_dim_r_slow);
    1874. 

  1874. 			}
    1875. 

  1875. 		} else {
    1876. 

  1876. ZEND_VM_C_LABEL(fetch_dim_r_slow):
    1877. 

  1877. 			if (OP2_TYPE == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
    1878. 

  1878. 				dim++;
    1879. 

  1879. 			}
    1880. 

  1880. 			zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
    1881. 

  1881. 		}
    1882. 

  1882. 	} else {
    1883. 

  1883. 		zend_fetch_dimension_address_read_R(container, dim, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC);
    1884. 

  1884. 	}
    1885. 

  1885. 	FREE_OP2();
    1886. 

  1886. 	FREE_OP1();
    1887. 

  1887. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1888. 

  1888. }
    1889. 

  1889. 

  1890. ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV)
    1891. 

  1891. {
    1892. 

  1892. 	USE_OPLINE
    1893. 

  1893. 	zval *container;
    1894. 

  1894. 

  1895. 	SAVE_OPLINE();
    1896. 

  1896. 	container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    1897. 

  1897. 	zend_fetch_dimension_address_W(container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE OPLINE_CC EXECUTE_DATA_CC);
    1898. 

  1898. 	FREE_OP2();
    1899. 

  1899. 	if (OP1_TYPE == IS_VAR) {
    1900. 

  1900. 		FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
    1901. 

  1901. 	}
    1902. 

  1902. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1903. 

  1903. }
    1904. 

  1904. 

  1905. ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV)
    1906. 

  1906. {
    1907. 

  1907. 	USE_OPLINE
    1908. 

  1908. 	zval *container;
    1909. 

  1909. 

  1910. 	SAVE_OPLINE();
    1911. 

  1911. 	container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    1912. 

  1912. 	zend_fetch_dimension_address_RW(container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE OPLINE_CC EXECUTE_DATA_CC);
    1913. 

  1913. 	FREE_OP2();
    1914. 

  1914. 	if (OP1_TYPE == IS_VAR) {
    1915. 

  1915. 		FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
    1916. 

  1916. 	}
    1917. 

  1917. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1918. 

  1918. }
    1919. 

  1919. 

  1920. ZEND_VM_COLD_CONSTCONST_HANDLER(90, ZEND_FETCH_DIM_IS, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
    1921. 

  1921. {
    1922. 

  1922. 	USE_OPLINE
    1923. 

  1923. 	zval *container;
    1924. 

  1924. 

  1925. 	SAVE_OPLINE();
    1926. 

  1926. 	container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_IS);
    1927. 

  1927. 	zend_fetch_dimension_address_read_IS(container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE OPLINE_CC EXECUTE_DATA_CC);
    1928. 

  1928. 	FREE_OP2();
    1929. 

  1929. 	FREE_OP1();
    1930. 

  1930. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1931. 

  1931. }
    1932. 

  1932. 

  1933. ZEND_VM_COLD_HELPER(zend_use_tmp_in_write_context_helper, ANY, ANY)
    1934. 

  1934. {
    1935. 

  1935. 	USE_OPLINE
    1936. 

  1936. 

  1937. 	SAVE_OPLINE();
    1938. 

  1938. 	zend_throw_error(NULL, "Cannot use temporary expression in write context");
    1939. 

  1939. 	FREE_UNFETCHED_OP2();
    1940. 

  1940. 	FREE_UNFETCHED_OP1();
    1941. 

  1941. 	ZVAL_UNDEF(EX_VAR(opline->result.var));
    1942. 

  1942. 	HANDLE_EXCEPTION();
    1943. 

  1943. }
    1944. 

  1944. 

  1945. ZEND_VM_COLD_HELPER(zend_use_undef_in_read_context_helper, ANY, ANY)
    1946. 

  1946. {
    1947. 

  1947. 	USE_OPLINE
    1948. 

  1948. 

  1949. 	SAVE_OPLINE();
    1950. 

  1950. 	zend_throw_error(NULL, "Cannot use [] for reading");
    1951. 

  1951. 	FREE_UNFETCHED_OP2();
    1952. 

  1952. 	FREE_UNFETCHED_OP1();
    1953. 

  1953. 	ZVAL_UNDEF(EX_VAR(opline->result.var));
    1954. 

  1954. 	HANDLE_EXCEPTION();
    1955. 

  1955. }
    1956. 

  1956. 

  1957. ZEND_VM_COLD_CONSTCONST_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV)
    1958. 

  1958. {
    1959. 

  1959. #if !ZEND_VM_SPEC
    1960. 

  1960. 	USE_OPLINE
    1961. 

  1961. #endif
    1962. 

  1962. 

  1963. 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
    1964. 

  1964.         if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) {
    1965. 

  1965. 			ZEND_VM_DISPATCH_TO_HELPER(zend_use_tmp_in_write_context_helper);
    1966. 

  1966.         }
    1967. 

  1967. 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_DIM_W);
    1968. 

  1968. 	} else {
    1969. 

  1969. 		if (OP2_TYPE == IS_UNUSED) {
    1970. 

  1970. 			ZEND_VM_DISPATCH_TO_HELPER(zend_use_undef_in_read_context_helper);
    1971. 

  1971. 		}
    1972. 

  1972. 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_DIM_R);
    1973. 

  1973. 	}
    1974. 

  1974. }
    1975. 

  1975. 

  1976. ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMPVAR|CV)
    1977. 

  1977. {
    1978. 

  1978. 	USE_OPLINE
    1979. 

  1979. 	zval *container;
    1980. 

  1980. 

  1981. 	SAVE_OPLINE();
    1982. 

  1982. 	container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_UNSET);
    1983. 

  1983. 	zend_fetch_dimension_address_UNSET(container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE OPLINE_CC EXECUTE_DATA_CC);
    1984. 

  1984. 	FREE_OP2();
    1985. 

  1985. 	if (OP1_TYPE == IS_VAR) {
    1986. 

  1986. 		FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
    1987. 

  1987. 	}
    1988. 

  1988. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    1989. 

  1989. }
    1990. 

  1990. 

  1991. ZEND_VM_HOT_OBJ_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    1992. 

  1992. {
    1993. 

  1993. 	USE_OPLINE
    1994. 

  1994. 	zval *container;
    1995. 

  1995. 	zval *offset;
    1996. 

  1996. 	void **cache_slot = NULL;
    1997. 

  1997. 

  1998. 	SAVE_OPLINE();
    1999. 

  1999. 	container = GET_OP1_OBJ_ZVAL_PTR_UNDEF(BP_VAR_R);
    2000. 

  2000. 	offset = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    2001. 

  2001. 

  2002. 	if (OP1_TYPE == IS_CONST ||
    2003. 

  2003. 	    (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
    2004. 

  2004. 	    do {
    2005. 

  2005. 			if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
    2006. 

  2006. 				container = Z_REFVAL_P(container);
    2007. 

  2007. 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
    2008. 

  2008. 					break;
    2009. 

  2009. 				}
    2010. 

  2010. 			}
    2011. 

  2011. 			if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
    2012. 

  2012. 				ZVAL_UNDEFINED_OP1();
    2013. 

  2013. 			}
    2014. 

  2014. 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
    2015. 

  2015. 				ZVAL_UNDEFINED_OP2();
    2016. 

  2016. 			}
    2017. 

  2017. 			zend_wrong_property_read(offset);
    2018. 

  2018. 			ZVAL_NULL(EX_VAR(opline->result.var));
    2019. 

  2019. 			ZEND_VM_C_GOTO(fetch_obj_r_finish);
    2020. 

  2020. 		} while (0);
    2021. 

  2021. 	}
    2022. 

  2022. 

  2023. 	/* here we are sure we are dealing with an object */
    2024. 

  2024. 	do {
    2025. 

  2025. 		zend_object *zobj = Z_OBJ_P(container);
    2026. 

  2026. 		zend_string *name, *tmp_name;
    2027. 

  2027. 		zval *retval;
    2028. 

  2028. 

  2029. 		if (OP2_TYPE == IS_CONST) {
    2030. 

  2030. 			name = Z_STR_P(offset);
    2031. 

  2031. 			cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
    2032. 

  2032. 

  2033. 			if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
    2034. 

  2034. 				uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
    2035. 

  2035. 

  2036. 				if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
    2037. 

  2037. 					retval = OBJ_PROP(zobj, prop_offset);
    2038. 

  2038. 					if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
    2039. 

  2039. 						if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) {
    2040. 

  2040. 							ZEND_VM_C_GOTO(fetch_obj_r_copy);
    2041. 

  2041. 						} else {
    2042. 

  2042. ZEND_VM_C_LABEL(fetch_obj_r_fast_copy):
    2043. 

  2043. 							ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
    2044. 

  2044. 							ZEND_VM_NEXT_OPCODE();
    2045. 

  2045. 						}
    2046. 

  2046. 					}
    2047. 

  2047. 				} else if (EXPECTED(zobj->properties != NULL)) {
    2048. 

  2048. 					if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
    2049. 

  2049. 						uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
    2050. 

  2050. 

  2051. 						if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
    2052. 

  2052. 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
    2053. 

  2053. 

  2054. 							if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
    2055. 

  2055. 						        (EXPECTED(p->key == name) ||
    2056. 

  2056. 						         (EXPECTED(p->h == ZSTR_H(name)) &&
    2057. 

  2057. 						          EXPECTED(p->key != NULL) &&
    2058. 

  2058. 						          EXPECTED(zend_string_equal_content(p->key, name))))) {
    2059. 

  2059. 								retval = &p->val;
    2060. 

  2060. 								if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) {
    2061. 

  2061. 									ZEND_VM_C_GOTO(fetch_obj_r_copy);
    2062. 

  2062. 								} else {
    2063. 

  2063. 									ZEND_VM_C_GOTO(fetch_obj_r_fast_copy);
    2064. 

  2064. 								}
    2065. 

  2065. 							}
    2066. 

  2066. 						}
    2067. 

  2067. 						CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
    2068. 

  2068. 					}
    2069. 

  2069. 					retval = zend_hash_find_ex(zobj->properties, name, 1);
    2070. 

  2070. 					if (EXPECTED(retval)) {
    2071. 

  2071. 						uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
    2072. 

  2072. 						CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
    2073. 

  2073. 						if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) {
    2074. 

  2074. 							ZEND_VM_C_GOTO(fetch_obj_r_copy);
    2075. 

  2075. 						} else {
    2076. 

  2076. 							ZEND_VM_C_GOTO(fetch_obj_r_fast_copy);
    2077. 

  2077. 						}
    2078. 

  2078. 					}
    2079. 

  2079. 				}
    2080. 

  2080. 			}
    2081. 

  2081. 		} else {
    2082. 

  2082. 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(offset) == IS_UNDEF)) {
    2083. 

  2083. 				ZVAL_UNDEFINED_OP2();
    2084. 

  2084. 			}
    2085. 

  2085. 			name = zval_try_get_tmp_string(offset, &tmp_name);
    2086. 

  2086. 			if (UNEXPECTED(!name)) {
    2087. 

  2087. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    2088. 

  2088. 				break;
    2089. 

  2089. 			}
    2090. 

  2090. 		}
    2091. 

  2091. 

  2092. 		retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
    2093. 

  2093. 

  2094. 		if (OP2_TYPE != IS_CONST) {
    2095. 

  2095. 			zend_tmp_string_release(tmp_name);
    2096. 

  2096. 		}
    2097. 

  2097. 

  2098. 		if (retval != EX_VAR(opline->result.var)) {
    2099. 

  2099. ZEND_VM_C_LABEL(fetch_obj_r_copy):
    2100. 

  2100. 			ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
    2101. 

  2101. 		} else if (UNEXPECTED(Z_ISREF_P(retval))) {
    2102. 

  2102. 			zend_unwrap_reference(retval);
    2103. 

  2103. 		}
    2104. 

  2104. 	} while (0);
    2105. 

  2105. 

  2106. ZEND_VM_C_LABEL(fetch_obj_r_finish):
    2107. 

  2107. 	FREE_OP2();
    2108. 

  2108. 	FREE_OP1();
    2109. 

  2109. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2110. 

  2110. }
    2111. 

  2111. 

  2112. ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, FETCH_REF|DIM_WRITE|CACHE_SLOT)
    2113. 

  2113. {
    2114. 

  2114. 	USE_OPLINE
    2115. 

  2115. 	zval *property, *container, *result;
    2116. 

  2116. 

  2117. 	SAVE_OPLINE();
    2118. 

  2118. 

  2119. 	container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    2120. 

  2120. 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2121. 

  2121. 	result = EX_VAR(opline->result.var);
    2122. 

  2122. 	zend_fetch_property_address(
    2123. 

  2123. 		result, container, OP1_TYPE, property, OP2_TYPE,
    2124. 

  2124. 		((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
    2125. 

  2125. 		BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC EXECUTE_DATA_CC);
    2126. 

  2126. 	FREE_OP2();
    2127. 

  2127. 	if (OP1_TYPE == IS_VAR) {
    2128. 

  2128. 		FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
    2129. 

  2129. 	}
    2130. 

  2130. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2131. 

  2131. }
    2132. 

  2132. 

  2133. ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    2134. 

  2134. {
    2135. 

  2135. 	USE_OPLINE
    2136. 

  2136. 	zval *property, *container, *result;
    2137. 

  2137. 

  2138. 	SAVE_OPLINE();
    2139. 

  2139. 	container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    2140. 

  2140. 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2141. 

  2141. 	result = EX_VAR(opline->result.var);
    2142. 

  2142. 	zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC EXECUTE_DATA_CC);
    2143. 

  2143. 	FREE_OP2();
    2144. 

  2144. 	if (OP1_TYPE == IS_VAR) {
    2145. 

  2145. 		FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
    2146. 

  2146. 	}
    2147. 

  2147. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2148. 

  2148. }
    2149. 

  2149. 

  2150. ZEND_VM_COLD_CONST_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    2151. 

  2151. {
    2152. 

  2152. 	USE_OPLINE
    2153. 

  2153. 	zval *container;
    2154. 

  2154. 	zval *offset;
    2155. 

  2155. 	void **cache_slot = NULL;
    2156. 

  2156. 

  2157. 	SAVE_OPLINE();
    2158. 

  2158. 	container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
    2159. 

  2159. 	offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2160. 

  2160. 

  2161. 	if (OP1_TYPE == IS_CONST ||
    2162. 

  2162. 	    (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
    2163. 

  2163. 		do {
    2164. 

  2164. 			if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
    2165. 

  2165. 				container = Z_REFVAL_P(container);
    2166. 

  2166. 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
    2167. 

  2167. 					break;
    2168. 

  2168. 				}
    2169. 

  2169. 			}
    2170. 

  2170. 			ZVAL_NULL(EX_VAR(opline->result.var));
    2171. 

  2171. 			ZEND_VM_C_GOTO(fetch_obj_is_finish);
    2172. 

  2172. 		} while (0);
    2173. 

  2173. 	}
    2174. 

  2174. 

  2175. 	/* here we are sure we are dealing with an object */
    2176. 

  2176. 	do {
    2177. 

  2177. 		zend_object *zobj = Z_OBJ_P(container);
    2178. 

  2178. 		zend_string *name, *tmp_name;
    2179. 

  2179. 		zval *retval;
    2180. 

  2180. 

  2181. 		if (OP2_TYPE == IS_CONST) {
    2182. 

  2182. 			name = Z_STR_P(offset);
    2183. 

  2183. 			cache_slot = CACHE_ADDR(opline->extended_value);
    2184. 

  2184. 

  2185. 			if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
    2186. 

  2186. 				uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
    2187. 

  2187. 

  2188. 				if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
    2189. 

  2189. 					retval = OBJ_PROP(zobj, prop_offset);
    2190. 

  2190. 					if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
    2191. 

  2191. 						if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) {
    2192. 

  2192. 							ZEND_VM_C_GOTO(fetch_obj_is_copy);
    2193. 

  2193. 						} else {
    2194. 

  2194. ZEND_VM_C_LABEL(fetch_obj_is_fast_copy):
    2195. 

  2195. 							ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
    2196. 

  2196. 							ZEND_VM_NEXT_OPCODE();
    2197. 

  2197. 						}
    2198. 

  2198. 					}
    2199. 

  2199. 				} else if (EXPECTED(zobj->properties != NULL)) {
    2200. 

  2200. 					if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
    2201. 

  2201. 						uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
    2202. 

  2202. 

  2203. 						if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
    2204. 

  2204. 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
    2205. 

  2205. 

  2206. 							if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
    2207. 

  2207. 						        (EXPECTED(p->key == name) ||
    2208. 

  2208. 						         (EXPECTED(p->h == ZSTR_H(name)) &&
    2209. 

  2209. 						          EXPECTED(p->key != NULL) &&
    2210. 

  2210. 						          EXPECTED(zend_string_equal_content(p->key, name))))) {
    2211. 

  2211. 								retval = &p->val;
    2212. 

  2212. 								if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) {
    2213. 

  2213. 									ZEND_VM_C_GOTO(fetch_obj_is_copy);
    2214. 

  2214. 								} else {
    2215. 

  2215. 									ZEND_VM_C_GOTO(fetch_obj_is_fast_copy);
    2216. 

  2216. 								}
    2217. 

  2217. 							}
    2218. 

  2218. 						}
    2219. 

  2219. 						CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
    2220. 

  2220. 					}
    2221. 

  2221. 					retval = zend_hash_find_ex(zobj->properties, name, 1);
    2222. 

  2222. 					if (EXPECTED(retval)) {
    2223. 

  2223. 						uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
    2224. 

  2224. 						CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
    2225. 

  2225. 						if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) {
    2226. 

  2226. 							ZEND_VM_C_GOTO(fetch_obj_is_copy);
    2227. 

  2227. 						} else {
    2228. 

  2228. 							ZEND_VM_C_GOTO(fetch_obj_is_fast_copy);
    2229. 

  2229. 						}
    2230. 

  2230. 					}
    2231. 

  2231. 				}
    2232. 

  2232. 			}
    2233. 

  2233. 		} else {
    2234. 

  2234. 			name = zval_try_get_tmp_string(offset, &tmp_name);
    2235. 

  2235. 			if (UNEXPECTED(!name)) {
    2236. 

  2236. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    2237. 

  2237. 				break;
    2238. 

  2238. 			}
    2239. 

  2239. 		}
    2240. 

  2240. 

  2241. 		retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
    2242. 

  2242. 

  2243. 		if (OP2_TYPE != IS_CONST) {
    2244. 

  2244. 			zend_tmp_string_release(tmp_name);
    2245. 

  2245. 		}
    2246. 

  2246. 

  2247. 		if (retval != EX_VAR(opline->result.var)) {
    2248. 

  2248. ZEND_VM_C_LABEL(fetch_obj_is_copy):
    2249. 

  2249. 			ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
    2250. 

  2250. 		} else if (UNEXPECTED(Z_ISREF_P(retval))) {
    2251. 

  2251. 			zend_unwrap_reference(retval);
    2252. 

  2252. 		}
    2253. 

  2253. 	} while (0);
    2254. 

  2254. 

  2255. ZEND_VM_C_LABEL(fetch_obj_is_finish):
    2256. 

  2256. 	FREE_OP2();
    2257. 

  2257. 	FREE_OP1();
    2258. 

  2258. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2259. 

  2259. }
    2260. 

  2260. 

  2261. ZEND_VM_COLD_CONST_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, FETCH_REF|CACHE_SLOT)
    2262. 

  2262. {
    2263. 

  2263. #if !ZEND_VM_SPEC
    2264. 

  2264. 	USE_OPLINE
    2265. 

  2265. #endif
    2266. 

  2266. 

  2267. 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
    2268. 

  2268. 		/* Behave like FETCH_OBJ_W */
    2269. 

  2269. 		if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) {
    2270. 

  2270. 			ZEND_VM_DISPATCH_TO_HELPER(zend_use_tmp_in_write_context_helper);
    2271. 

  2271. 		}
    2272. 

  2272. 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_OBJ_W);
    2273. 

  2273. 	} else {
    2274. 

  2274. 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_OBJ_R);
    2275. 

  2275. 	}
    2276. 

  2276. }
    2277. 

  2277. 

  2278. ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    2279. 

  2279. {
    2280. 

  2280. 	USE_OPLINE
    2281. 

  2281. 	zval *container, *property, *result;
    2282. 

  2282. 

  2283. 	SAVE_OPLINE();
    2284. 

  2284. 	container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_UNSET);
    2285. 

  2285. 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2286. 

  2286. 	result = EX_VAR(opline->result.var);
    2287. 

  2287. 	zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC EXECUTE_DATA_CC);
    2288. 

  2288. 	FREE_OP2();
    2289. 

  2289. 	if (OP1_TYPE == IS_VAR) {
    2290. 

  2290. 		FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
    2291. 

  2291. 	}
    2292. 

  2292. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2293. 

  2293. }
    2294. 

  2294. 

  2295. ZEND_VM_HANDLER(98, ZEND_FETCH_LIST_R, CONST|TMPVARCV, CONST|TMPVAR|CV)
    2296. 

  2296. {
    2297. 

  2297. 	USE_OPLINE
    2298. 

  2298. 	zval *container;
    2299. 

  2299. 

  2300. 	SAVE_OPLINE();
    2301. 

  2301. 	container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    2302. 

  2302. 	zend_fetch_dimension_address_LIST_r(container, GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R), OP2_TYPE OPLINE_CC EXECUTE_DATA_CC);
    2303. 

  2303. 	FREE_OP2();
    2304. 

  2304. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2305. 

  2305. }
    2306. 

  2306. 

  2307. ZEND_VM_HANDLER(155, ZEND_FETCH_LIST_W, VAR, CONST|TMPVAR|CV)
    2308. 

  2308. {
    2309. 

  2309. 	USE_OPLINE
    2310. 

  2310. 	zval *container, *dim;
    2311. 

  2311. 

  2312. 	SAVE_OPLINE();
    2313. 

  2313. 	container = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    2314. 

  2314. 	dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    2315. 

  2315. 

  2316. 	if (OP1_TYPE == IS_VAR
    2317. 

  2317. 		&& Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
    2318. 

  2318. 		&& UNEXPECTED(!Z_ISREF_P(container))
    2319. 

  2319. 	) {
    2320. 

  2320. 		zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
    2321. 

  2321. 		zend_fetch_dimension_address_LIST_r(container, dim, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC);
    2322. 

  2322. 	} else {
    2323. 

  2323. 		zend_fetch_dimension_address_W(container, dim, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC);
    2324. 

  2324. 	}
    2325. 

  2325. 

  2326. 	FREE_OP2();
    2327. 

  2327. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2328. 

  2328. }
    2329. 

  2329. 

  2330. ZEND_VM_HANDLER(24, ZEND_ASSIGN_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT, SPEC(OP_DATA=CONST|TMP|VAR|CV))
    2331. 

  2331. {
    2332. 

  2332. 	USE_OPLINE
    2333. 

  2333. 	zval *object, *property, *value, tmp;
    2334. 

  2334. 	zend_object *zobj;
    2335. 

  2335. 	zend_string *name, *tmp_name;
    2336. 

  2336. 

  2337. 	SAVE_OPLINE();
    2338. 

  2338. 	object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    2339. 

  2339. 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2340. 

  2340. 	value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
    2341. 

  2341. 

  2342. 	if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
    2343. 

  2343. 		if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
    2344. 

  2344. 			object = Z_REFVAL_P(object);
    2345. 

  2345. 			ZEND_VM_C_GOTO(assign_object);
    2346. 

  2346. 		}
    2347. 

  2347. 		zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
    2348. 

  2348. 		value = &EG(uninitialized_zval);
    2349. 

  2349. 		ZEND_VM_C_GOTO(free_and_exit_assign_obj);
    2350. 

  2350. 	}
    2351. 

  2351. 

  2352. ZEND_VM_C_LABEL(assign_object):
    2353. 

  2353. 	zobj = Z_OBJ_P(object);
    2354. 

  2354. 	if (OP2_TYPE == IS_CONST &&
    2355. 

  2355. 	    EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
    2356. 

  2356. 		void **cache_slot = CACHE_ADDR(opline->extended_value);
    2357. 

  2357. 		uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
    2358. 

  2358. 		zend_object *zobj = Z_OBJ_P(object);
    2359. 

  2359. 		zval *property_val;
    2360. 

  2360. 

  2361. 		if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
    2362. 

  2362. 			property_val = OBJ_PROP(zobj, prop_offset);
    2363. 

  2363. 			if (Z_TYPE_P(property_val) != IS_UNDEF) {
    2364. 

  2364. 				zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
    2365. 

  2365. 

  2366. 				if (UNEXPECTED(prop_info != NULL)) {
    2367. 

  2367. 					zend_uchar orig_type = IS_UNDEF;
    2368. 

  2368. 

  2369. 					if (OP_DATA_TYPE == IS_CONST) {
    2370. 

  2370. 						orig_type = Z_TYPE_P(value);
    2371. 

  2371. 					}
    2372. 

  2372. 

  2373. 					value = zend_assign_to_typed_prop(prop_info, property_val, value EXECUTE_DATA_CC);
    2374. 

  2374. 

  2375. 					/* will remain valid, thus no need to check prop_info in future here */
    2376. 

  2376. 					if (OP_DATA_TYPE == IS_CONST && Z_TYPE_P(value) == orig_type) {
    2377. 

  2377. 						CACHE_PTR_EX(cache_slot + 2, NULL);
    2378. 

  2378. 					}
    2379. 

  2379. 					ZEND_VM_C_GOTO(free_and_exit_assign_obj);
    2380. 

  2380. 				} else {
    2381. 

  2381. ZEND_VM_C_LABEL(fast_assign_obj):
    2382. 

  2382. 					value = zend_assign_to_variable(property_val, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES());
    2383. 

  2383. 					if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2384. 

  2384. 						ZVAL_COPY(EX_VAR(opline->result.var), value);
    2385. 

  2385. 					}
    2386. 

  2386. 					ZEND_VM_C_GOTO(exit_assign_obj);
    2387. 

  2387. 				}
    2388. 

  2388. 			}
    2389. 

  2389. 		} else {
    2390. 

  2390. 			if (EXPECTED(zobj->properties != NULL)) {
    2391. 

  2391. 				if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
    2392. 

  2392. 					if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
    2393. 

  2393. 						GC_DELREF(zobj->properties);
    2394. 

  2394. 					}
    2395. 

  2395. 					zobj->properties = zend_array_dup(zobj->properties);
    2396. 

  2396. 				}
    2397. 

  2397. 				property_val = zend_hash_find_ex(zobj->properties, Z_STR_P(property), 1);
    2398. 

  2398. 				if (property_val) {
    2399. 

  2399. 					ZEND_VM_C_GOTO(fast_assign_obj);
    2400. 

  2400. 				}
    2401. 

  2401. 			}
    2402. 

  2402. 

  2403. 			if (!zobj->ce->__set) {
    2404. 

  2404. 

  2405. 				if (EXPECTED(zobj->properties == NULL)) {
    2406. 

  2406. 					rebuild_object_properties(zobj);
    2407. 

  2407. 				}
    2408. 

  2408. 				if (OP_DATA_TYPE == IS_CONST) {
    2409. 

  2409. 					if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
    2410. 

  2410. 						Z_ADDREF_P(value);
    2411. 

  2411. 					}
    2412. 

  2412. 				} else if (OP_DATA_TYPE != IS_TMP_VAR) {
    2413. 

  2413. 					if (Z_ISREF_P(value)) {
    2414. 

  2414. 						if (OP_DATA_TYPE == IS_VAR) {
    2415. 

  2415. 							zend_reference *ref = Z_REF_P(value);
    2416. 

  2416. 							if (GC_DELREF(ref) == 0) {
    2417. 

  2417. 								ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
    2418. 

  2418. 								efree_size(ref, sizeof(zend_reference));
    2419. 

  2419. 								value = &tmp;
    2420. 

  2420. 							} else {
    2421. 

  2421. 								value = Z_REFVAL_P(value);
    2422. 

  2422. 								Z_TRY_ADDREF_P(value);
    2423. 

  2423. 							}
    2424. 

  2424. 						} else {
    2425. 

  2425. 							value = Z_REFVAL_P(value);
    2426. 

  2426. 							Z_TRY_ADDREF_P(value);
    2427. 

  2427. 						}
    2428. 

  2428. 					} else if (OP_DATA_TYPE == IS_CV) {
    2429. 

  2429. 						Z_TRY_ADDREF_P(value);
    2430. 

  2430. 					}
    2431. 

  2431. 				}
    2432. 

  2432. 				zend_hash_add_new(zobj->properties, Z_STR_P(property), value);
    2433. 

  2433. 				if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2434. 

  2434. 					ZVAL_COPY(EX_VAR(opline->result.var), value);
    2435. 

  2435. 				}
    2436. 

  2436. 				ZEND_VM_C_GOTO(exit_assign_obj);
    2437. 

  2437. 			}
    2438. 

  2438. 		}
    2439. 

  2439. 	}
    2440. 

  2440. 

  2441. 	if (OP_DATA_TYPE == IS_CV || OP_DATA_TYPE == IS_VAR) {
    2442. 

  2442. 		ZVAL_DEREF(value);
    2443. 

  2443. 	}
    2444. 

  2444. 

  2445. 	if (OP2_TYPE == IS_CONST) {
    2446. 

  2446. 		name = Z_STR_P(property);
    2447. 

  2447. 	} else {
    2448. 

  2448. 		name = zval_try_get_tmp_string(property, &tmp_name);
    2449. 

  2449. 		if (UNEXPECTED(!name)) {
    2450. 

  2450. 			FREE_OP_DATA();
    2451. 

  2451. 			UNDEF_RESULT();
    2452. 

  2452. 			ZEND_VM_C_GOTO(exit_assign_obj);
    2453. 

  2453. 		}
    2454. 

  2454. 	}
    2455. 

  2455. 

  2456. 	value = zobj->handlers->write_property(zobj, name, value, (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
    2457. 

  2457. 

  2458. 	if (OP2_TYPE != IS_CONST) {
    2459. 

  2459. 		zend_tmp_string_release(tmp_name);
    2460. 

  2460. 	}
    2461. 

  2461. 

  2462. ZEND_VM_C_LABEL(free_and_exit_assign_obj):
    2463. 

  2463. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2464. 

  2464. 		ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
    2465. 

  2465. 	}
    2466. 

  2466. 	FREE_OP_DATA();
    2467. 

  2467. ZEND_VM_C_LABEL(exit_assign_obj):
    2468. 

  2468. 	FREE_OP2();
    2469. 

  2469. 	FREE_OP1_VAR_PTR();
    2470. 

  2470. 	/* assign_obj has two opcodes! */
    2471. 

  2471. 	ZEND_VM_NEXT_OPCODE_EX(1, 2);
    2472. 

  2472. }
    2473. 

  2473. 

  2474. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
    2475. 

  2475. ZEND_VM_HANDLER(25, ZEND_ASSIGN_STATIC_PROP, ANY, ANY, CACHE_SLOT, SPEC(OP_DATA=CONST|TMP|VAR|CV))
    2476. 

  2476. {
    2477. 

  2477. 	USE_OPLINE
    2478. 

  2478. 	zval *prop, *value;
    2479. 

  2479. 	zend_property_info *prop_info;
    2480. 

  2480. 

  2481. 	SAVE_OPLINE();
    2482. 

  2482. 

  2483. 	if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
    2484. 

  2484. 		FREE_UNFETCHED_OP_DATA();
    2485. 

  2485. 		UNDEF_RESULT();
    2486. 

  2486. 		HANDLE_EXCEPTION();
    2487. 

  2487. 	}
    2488. 

  2488. 

  2489. 	value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
    2490. 

  2490. 

  2491. 	if (UNEXPECTED(ZEND_TYPE_IS_SET(prop_info->type))) {
    2492. 

  2492. 		value = zend_assign_to_typed_prop(prop_info, prop, value EXECUTE_DATA_CC);
    2493. 

  2493. 		FREE_OP_DATA();
    2494. 

  2494. 	} else {
    2495. 

  2495. 		value = zend_assign_to_variable(prop, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES());
    2496. 

  2496. 	}
    2497. 

  2497. 

  2498. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2499. 

  2499. 		ZVAL_COPY(EX_VAR(opline->result.var), value);
    2500. 

  2500. 	}
    2501. 

  2501. 

  2502. 	/* assign_static_prop has two opcodes! */
    2503. 

  2503. 	ZEND_VM_NEXT_OPCODE_EX(1, 2);
    2504. 

  2504. }
    2505. 

  2505. 

  2506. ZEND_VM_HANDLER(23, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, SPEC(OP_DATA=CONST|TMP|VAR|CV))
    2507. 

  2507. {
    2508. 

  2508. 	USE_OPLINE
    2509. 

  2509. 	zval *object_ptr, *orig_object_ptr;
    2510. 

  2510. 	zval *value;
    2511. 

  2511. 	zval *variable_ptr;
    2512. 

  2512. 	zval *dim;
    2513. 

  2513. 

  2514. 	SAVE_OPLINE();
    2515. 

  2515. 	orig_object_ptr = object_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    2516. 

  2516. 

  2517. 	if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
    2518. 

  2518. ZEND_VM_C_LABEL(try_assign_dim_array):
    2519. 

  2519. 		SEPARATE_ARRAY(object_ptr);
    2520. 

  2520. 		if (OP2_TYPE == IS_UNUSED) {
    2521. 

  2521. 			value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
    2522. 

  2522. 			if (OP_DATA_TYPE == IS_CV || OP_DATA_TYPE == IS_VAR) {
    2523. 

  2523. 				ZVAL_DEREF(value);
    2524. 

  2524. 			}
    2525. 

  2525. 			variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
    2526. 

  2526. 			if (UNEXPECTED(variable_ptr == NULL)) {
    2527. 

  2527. 				FREE_OP_DATA();
    2528. 

  2528. 				zend_cannot_add_element();
    2529. 

  2529. 				ZEND_VM_C_GOTO(assign_dim_error);
    2530. 

  2530. 			} else if (OP_DATA_TYPE == IS_CV) {
    2531. 

  2531. 				if (Z_REFCOUNTED_P(value)) {
    2532. 

  2532. 					Z_ADDREF_P(value);
    2533. 

  2533. 				}
    2534. 

  2534. 			} else if (OP_DATA_TYPE == IS_VAR) {
    2535. 

  2535. 				zval *free_op_data = EX_VAR((opline+1)->op1.var);
    2536. 

  2536. 				if (value != free_op_data) {
    2537. 

  2537. 					if (Z_REFCOUNTED_P(value)) {
    2538. 

  2538. 						Z_ADDREF_P(value);
    2539. 

  2539. 					}
    2540. 

  2540. 					zval_ptr_dtor_nogc(free_op_data);
    2541. 

  2541. 				}
    2542. 

  2542. 			} else if (OP_DATA_TYPE == IS_CONST) {
    2543. 

  2543. 				if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
    2544. 

  2544. 					Z_ADDREF_P(value);
    2545. 

  2545. 				}
    2546. 

  2546. 			}
    2547. 

  2547. 		} else {
    2548. 

  2548. 			dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    2549. 

  2549. 			if (OP2_TYPE == IS_CONST) {
    2550. 

  2550. 				variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
    2551. 

  2551. 			} else {
    2552. 

  2552. 				variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
    2553. 

  2553. 			}
    2554. 

  2554. 			if (UNEXPECTED(variable_ptr == NULL)) {
    2555. 

  2555. 				ZEND_VM_C_GOTO(assign_dim_error);
    2556. 

  2556. 			}
    2557. 

  2557. 			value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
    2558. 

  2558. 			value = zend_assign_to_variable(variable_ptr, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES());
    2559. 

  2559. 		}
    2560. 

  2560. 		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2561. 

  2561. 			ZVAL_COPY(EX_VAR(opline->result.var), value);
    2562. 

  2562. 		}
    2563. 

  2563. 	} else {
    2564. 

  2564. 		if (EXPECTED(Z_ISREF_P(object_ptr))) {
    2565. 

  2565. 			object_ptr = Z_REFVAL_P(object_ptr);
    2566. 

  2566. 			if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
    2567. 

  2567. 				ZEND_VM_C_GOTO(try_assign_dim_array);
    2568. 

  2568. 			}
    2569. 

  2569. 		}
    2570. 

  2570. 		if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
    2571. 

  2571. 			dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2572. 

  2572. 			value = GET_OP_DATA_ZVAL_PTR_DEREF(BP_VAR_R);
    2573. 

  2573. 

  2574. 			if (OP2_TYPE == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
    2575. 

  2575. 				dim++;
    2576. 

  2576. 			}
    2577. 

  2577. 			zend_assign_to_object_dim(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
    2578. 

  2578. 

  2579. 			FREE_OP_DATA();
    2580. 

  2580. 		} else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
    2581. 

  2581. 			if (OP2_TYPE == IS_UNUSED) {
    2582. 

  2582. 				zend_use_new_element_for_string();
    2583. 

  2583. 				FREE_UNFETCHED_OP_DATA();
    2584. 

  2584. 				UNDEF_RESULT();
    2585. 

  2585. 			} else {
    2586. 

  2586. 				dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2587. 

  2587. 				value = GET_OP_DATA_ZVAL_PTR_DEREF(BP_VAR_R);
    2588. 

  2588. 				zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
    2589. 

  2589. 				FREE_OP_DATA();
    2590. 

  2590. 			}
    2591. 

  2591. 		} else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
    2592. 

  2592. 			if (Z_ISREF_P(orig_object_ptr)
    2593. 

  2593. 			 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
    2594. 

  2594. 			 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
    2595. 

  2595. 				dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2596. 

  2596. 				FREE_UNFETCHED_OP_DATA();
    2597. 

  2597. 				UNDEF_RESULT();
    2598. 

  2598. 			} else {
    2599. 

  2599. 				ZVAL_ARR(object_ptr, zend_new_array(8));
    2600. 

  2600. 				ZEND_VM_C_GOTO(try_assign_dim_array);
    2601. 

  2601. 			}
    2602. 

  2602. 		} else {
    2603. 

  2603. 			zend_use_scalar_as_array();
    2604. 

  2604. 			dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2605. 

  2605. ZEND_VM_C_LABEL(assign_dim_error):
    2606. 

  2606. 			FREE_UNFETCHED_OP_DATA();
    2607. 

  2607. 			if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2608. 

  2608. 				ZVAL_NULL(EX_VAR(opline->result.var));
    2609. 

  2609. 			}
    2610. 

  2610. 		}
    2611. 

  2611. 	}
    2612. 

  2612. 	if (OP2_TYPE != IS_UNUSED) {
    2613. 

  2613. 		FREE_OP2();
    2614. 

  2614. 	}
    2615. 

  2615. 	FREE_OP1_VAR_PTR();
    2616. 

  2616. 	/* assign_dim has two opcodes! */
    2617. 

  2617. 	ZEND_VM_NEXT_OPCODE_EX(1, 2);
    2618. 

  2618. }
    2619. 

  2619. 

  2620. ZEND_VM_HANDLER(22, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV, SPEC(RETVAL))
    2621. 

  2621. {
    2622. 

  2622. 	USE_OPLINE
    2623. 

  2623. 	zval *value;
    2624. 

  2624. 	zval *variable_ptr;
    2625. 

  2625. 

  2626. 	SAVE_OPLINE();
    2627. 

  2627. 	value = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2628. 

  2628. 	variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    2629. 

  2629. 

  2630. 	value = zend_assign_to_variable(variable_ptr, value, OP2_TYPE, EX_USES_STRICT_TYPES());
    2631. 

  2631. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2632. 

  2632. 		ZVAL_COPY(EX_VAR(opline->result.var), value);
    2633. 

  2633. 	}
    2634. 

  2634. 	FREE_OP1_VAR_PTR();
    2635. 

  2635. 	/* zend_assign_to_variable() always takes care of op2, never free it! */
    2636. 

  2636. 

  2637. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2638. 

  2638. }
    2639. 

  2639. 

  2640. ZEND_VM_HANDLER(30, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC)
    2641. 

  2641. {
    2642. 

  2642. 	USE_OPLINE
    2643. 

  2643. 	zval *variable_ptr;
    2644. 

  2644. 	zval *value_ptr;
    2645. 

  2645. 

  2646. 	SAVE_OPLINE();
    2647. 

  2647. 	value_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
    2648. 

  2648. 	variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    2649. 

  2649. 

  2650. 	if (OP1_TYPE == IS_VAR &&
    2651. 

  2651. 	           UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
    2652. 

  2652. 

  2653. 		zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
    2654. 

  2654. 		variable_ptr = &EG(uninitialized_zval);
    2655. 

  2655. 	} else if (OP2_TYPE == IS_VAR &&
    2656. 

  2656. 	           opline->extended_value == ZEND_RETURNS_FUNCTION &&
    2657. 

  2657. 			   UNEXPECTED(!Z_ISREF_P(value_ptr))) {
    2658. 

  2658. 

  2659. 		if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(variable_ptr, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
    2660. 

  2660. 			variable_ptr = &EG(uninitialized_zval);
    2661. 

  2661. 		}
    2662. 

  2662. 	} else {
    2663. 

  2663. 		zend_assign_to_variable_reference(variable_ptr, value_ptr);
    2664. 

  2664. 	}
    2665. 

  2665. 

  2666. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2667. 

  2667. 		ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
    2668. 

  2668. 	}
    2669. 

  2669. 

  2670. 	FREE_OP2_VAR_PTR();
    2671. 

  2671. 	FREE_OP1_VAR_PTR();
    2672. 

  2672. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    2673. 

  2673. }
    2674. 

  2674. 

  2675. ZEND_VM_HANDLER(32, ZEND_ASSIGN_OBJ_REF, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT|SRC, SPEC(OP_DATA=VAR|CV))
    2676. 

  2676. {
    2677. 

  2677. 	USE_OPLINE
    2678. 

  2678. 	zval *property, *container, *value_ptr;
    2679. 

  2679. 

  2680. 	SAVE_OPLINE();
    2681. 

  2681. 

  2682. 	container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    2683. 

  2683. 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
    2684. 

  2684. 

  2685. 	value_ptr = GET_OP_DATA_ZVAL_PTR_PTR(BP_VAR_W);
    2686. 

  2686. 

  2687. 	if (ZEND_VM_SPEC) {
    2688. 

  2688. 		if (OP1_TYPE == IS_UNUSED) {
    2689. 

  2689. 			if (OP2_TYPE == IS_CONST) {
    2690. 

  2690. 				zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
    2691. 

  2691. 			} else {
    2692. 

  2692. 				zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
    2693. 

  2693. 			}
    2694. 

  2694. 		} else {
    2695. 

  2695. 			if (OP2_TYPE == IS_CONST) {
    2696. 

  2696. 				zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
    2697. 

  2697. 			} else {
    2698. 

  2698. 				zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
    2699. 

  2699. 			}
    2700. 

  2700. 		}
    2701. 

  2701. 	} else {
    2702. 

  2702. 		zend_assign_to_property_reference(container, OP1_TYPE, property, OP2_TYPE, value_ptr OPLINE_CC EXECUTE_DATA_CC);
    2703. 

  2703. 	}
    2704. 

  2704. 

  2705. 	FREE_OP1_VAR_PTR();
    2706. 

  2706. 	FREE_OP2();
    2707. 

  2707. 	FREE_OP_DATA_VAR_PTR();
    2708. 

  2708. 	ZEND_VM_NEXT_OPCODE_EX(1, 2);
    2709. 

  2709. }
    2710. 

  2710. 

  2711. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
    2712. 

  2712. ZEND_VM_HANDLER(33, ZEND_ASSIGN_STATIC_PROP_REF, ANY, ANY, CACHE_SLOT|SRC)
    2713. 

  2713. {
    2714. 

  2714. 	USE_OPLINE
    2715. 

  2715. 	zval *prop, *value_ptr;
    2716. 

  2716. 	zend_property_info *prop_info;
    2717. 

  2717. 

  2718. 	SAVE_OPLINE();
    2719. 

  2719. 

  2720. 	if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
    2721. 

  2721. 		FREE_UNFETCHED_OP_DATA();
    2722. 

  2722. 		UNDEF_RESULT();
    2723. 

  2723. 		HANDLE_EXCEPTION();
    2724. 

  2724. 	}
    2725. 

  2725. 

  2726. 	value_ptr = GET_OP_DATA_ZVAL_PTR_PTR(BP_VAR_W);
    2727. 

  2727. 

  2728. 	if (OP_DATA_TYPE == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
    2729. 

  2729. 		if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr OPLINE_CC EXECUTE_DATA_CC))) {
    2730. 

  2730. 			prop = &EG(uninitialized_zval);
    2731. 

  2731. 		}
    2732. 

  2732. 	} else if (UNEXPECTED(ZEND_TYPE_IS_SET(prop_info->type))) {
    2733. 

  2733. 		prop = zend_assign_to_typed_property_reference(prop_info, prop, value_ptr EXECUTE_DATA_CC);
    2734. 

  2734. 	} else {
    2735. 

  2735. 		zend_assign_to_variable_reference(prop, value_ptr);
    2736. 

  2736. 	}
    2737. 

  2737. 

  2738. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    2739. 

  2739. 		ZVAL_COPY(EX_VAR(opline->result.var), prop);
    2740. 

  2740. 	}
    2741. 

  2741. 

  2742. 	FREE_OP_DATA_VAR_PTR();
    2743. 

  2743. 	ZEND_VM_NEXT_OPCODE_EX(1, 2);
    2744. 

  2744. }
    2745. 

  2745. 

  2746. ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY)
    2747. 

  2747. {
    2748. 

  2748. 	zend_execute_data *old_execute_data;
    2749. 

  2749. 	uint32_t call_info = EX_CALL_INFO();
    2750. 

  2750. 	SAVE_OPLINE();
    2751. 

  2751. 

  2752. 	if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED)) == 0)) {
    2753. 

  2753. 		EG(current_execute_data) = EX(prev_execute_data);
    2754. 

  2754. 		i_free_compiled_variables(execute_data);
    2755. 

  2755. 

  2756. #ifdef ZEND_PREFER_RELOAD
    2757. 

  2757. 		call_info = EX_CALL_INFO();
    2758. 

  2758. #endif
    2759. 

  2759. 		if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
    2760. 

  2760. 			OBJ_RELEASE(Z_OBJ(execute_data->This));
    2761. 

  2761. 		} else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
    2762. 

  2762. 			OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
    2763. 

  2763. 		}
    2764. 

  2764. 		EG(vm_stack_top) = (zval*)execute_data;
    2765. 

  2765. 		execute_data = EX(prev_execute_data);
    2766. 

  2766. 

  2767. 		if (UNEXPECTED(EG(exception) != NULL)) {
    2768. 

  2768. 			zend_rethrow_exception(execute_data);
    2769. 

  2769. 			HANDLE_EXCEPTION_LEAVE();
    2770. 

  2770. 		}
    2771. 

  2771. 

  2772. 		LOAD_NEXT_OPLINE();
    2773. 

  2773. 		ZEND_VM_LEAVE();
    2774. 

  2774. 	} else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
    2775. 

  2775. 		EG(current_execute_data) = EX(prev_execute_data);
    2776. 

  2776. 		i_free_compiled_variables(execute_data);
    2777. 

  2777. 

  2778. #ifdef ZEND_PREFER_RELOAD
    2779. 

  2779. 		call_info = EX_CALL_INFO();
    2780. 

  2780. #endif
    2781. 

  2781. 		if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
    2782. 

  2782. 			zend_clean_and_cache_symbol_table(EX(symbol_table));
    2783. 

  2783. 		}
    2784. 

  2784. 

  2785. 		/* Free extra args before releasing the closure,
    2786. 

  2786. 		 * as that may free the op_array. */
    2787. 

  2787. 		zend_vm_stack_free_extra_args_ex(call_info, execute_data);
    2788. 

  2788. 

  2789. 		if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
    2790. 

  2790. 			OBJ_RELEASE(Z_OBJ(execute_data->This));
    2791. 

  2791. 		} else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
    2792. 

  2792. 			OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
    2793. 

  2793. 		}
    2794. 

  2794. 

  2795. 		old_execute_data = execute_data;
    2796. 

  2796. 		execute_data = EX(prev_execute_data);
    2797. 

  2797. 		zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
    2798. 

  2798. 

  2799. 		if (UNEXPECTED(EG(exception) != NULL)) {
    2800. 

  2800. 			zend_rethrow_exception(execute_data);
    2801. 

  2801. 			HANDLE_EXCEPTION_LEAVE();
    2802. 

  2802. 		}
    2803. 

  2803. 

  2804. 		LOAD_NEXT_OPLINE();
    2805. 

  2805. 		ZEND_VM_LEAVE();
    2806. 

  2806. 	} else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
    2807. 

  2807. 		zend_detach_symbol_table(execute_data);
    2808. 

  2808. 		destroy_op_array(&EX(func)->op_array);
    2809. 

  2809. 		efree_size(EX(func), sizeof(zend_op_array));
    2810. 

  2810. #ifdef ZEND_PREFER_RELOAD
    2811. 

  2811. 		call_info = EX_CALL_INFO();
    2812. 

  2812. #endif
    2813. 

  2813. 		old_execute_data = execute_data;
    2814. 

  2814. 		execute_data = EG(current_execute_data) = EX(prev_execute_data);
    2815. 

  2815. 		zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
    2816. 

  2816. 

  2817. 		zend_attach_symbol_table(execute_data);
    2818. 

  2818. 		if (UNEXPECTED(EG(exception) != NULL)) {
    2819. 

  2819. 			zend_rethrow_exception(execute_data);
    2820. 

  2820. 			HANDLE_EXCEPTION_LEAVE();
    2821. 

  2821. 		}
    2822. 

  2822. 

  2823. 		LOAD_NEXT_OPLINE();
    2824. 

  2824. 		ZEND_VM_LEAVE();
    2825. 

  2825. 	} else {
    2826. 

  2826. 		if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
    2827. 

  2827. 			EG(current_execute_data) = EX(prev_execute_data);
    2828. 

  2828. 			i_free_compiled_variables(execute_data);
    2829. 

  2829. #ifdef ZEND_PREFER_RELOAD
    2830. 

  2830. 			call_info = EX_CALL_INFO();
    2831. 

  2831. #endif
    2832. 

  2832. 			if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS))) {
    2833. 

  2833. 				if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
    2834. 

  2834. 					zend_clean_and_cache_symbol_table(EX(symbol_table));
    2835. 

  2835. 				}
    2836. 

  2836. 				zend_vm_stack_free_extra_args_ex(call_info, execute_data);
    2837. 

  2837. 			}
    2838. 

  2838. 			if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
    2839. 

  2839. 				OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
    2840. 

  2840. 			}
    2841. 

  2841. 			ZEND_VM_RETURN();
    2842. 

  2842. 		} else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
    2843. 

  2843. 			zend_array *symbol_table = EX(symbol_table);
    2844. 

  2844. 

  2845. 			zend_detach_symbol_table(execute_data);
    2846. 

  2846. 			old_execute_data = EX(prev_execute_data);
    2847. 

  2847. 			while (old_execute_data) {
    2848. 

  2848. 				if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
    2849. 

  2849. 					if (old_execute_data->symbol_table == symbol_table) {
    2850. 

  2850. 						zend_attach_symbol_table(old_execute_data);
    2851. 

  2851. 					}
    2852. 

  2852. 					break;
    2853. 

  2853. 				}
    2854. 

  2854. 				old_execute_data = old_execute_data->prev_execute_data;
    2855. 

  2855. 			}
    2856. 

  2856. 			EG(current_execute_data) = EX(prev_execute_data);
    2857. 

  2857. 			ZEND_VM_RETURN();
    2858. 

  2858. 		}
    2859. 

  2859. 	}
    2860. 

  2860. }
    2861. 

  2861. 

  2862. ZEND_VM_HOT_HANDLER(42, ZEND_JMP, JMP_ADDR, ANY)
    2863. 

  2863. {
    2864. 

  2864. 	USE_OPLINE
    2865. 

  2865. 

  2866. 	ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
    2867. 

  2867. }
    2868. 

  2868. 

  2869. ZEND_VM_HOT_NOCONST_HANDLER(43, ZEND_JMPZ, CONST|TMPVAR|CV, JMP_ADDR)
    2870. 

  2870. {
    2871. 

  2871. 	USE_OPLINE
    2872. 

  2872. 	zval *val;
    2873. 

  2873. 	zend_uchar op1_type;
    2874. 

  2874. 

  2875. 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    2876. 

  2876. 

  2877. 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
    2878. 

  2878. 		ZEND_VM_NEXT_OPCODE();
    2879. 

  2879. 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
    2880. 

  2880. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
    2881. 

  2881. 			SAVE_OPLINE();
    2882. 

  2882. 			ZVAL_UNDEFINED_OP1();
    2883. 

  2883. 			if (UNEXPECTED(EG(exception))) {
    2884. 

  2884. 				HANDLE_EXCEPTION();
    2885. 

  2885. 			}
    2886. 

  2886. 		}
    2887. 

  2887. 		ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    2888. 

  2888. 	}
    2889. 

  2889. 

  2890. 	SAVE_OPLINE();
    2891. 

  2891. 	op1_type = OP1_TYPE;
    2892. 

  2892. 	if (i_zend_is_true(val)) {
    2893. 

  2893. 		opline++;
    2894. 

  2894. 	} else {
    2895. 

  2895. 		opline = OP_JMP_ADDR(opline, opline->op2);
    2896. 

  2896. 	}
    2897. 

  2897. 	if (op1_type & (IS_TMP_VAR|IS_VAR)) {
    2898. 

  2898. 		zval_ptr_dtor_nogc(val);
    2899. 

  2899. 	}
    2900. 

  2900. 	ZEND_VM_JMP(opline);
    2901. 

  2901. }
    2902. 

  2902. 

  2903. ZEND_VM_HOT_NOCONST_HANDLER(44, ZEND_JMPNZ, CONST|TMPVAR|CV, JMP_ADDR)
    2904. 

  2904. {
    2905. 

  2905. 	USE_OPLINE
    2906. 

  2906. 	zval *val;
    2907. 

  2907. 	zend_uchar op1_type;
    2908. 

  2908. 

  2909. 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    2910. 

  2910. 

  2911. 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
    2912. 

  2912. 		ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    2913. 

  2913. 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
    2914. 

  2914. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
    2915. 

  2915. 			SAVE_OPLINE();
    2916. 

  2916. 			ZVAL_UNDEFINED_OP1();
    2917. 

  2917. 			if (UNEXPECTED(EG(exception))) {
    2918. 

  2918. 				HANDLE_EXCEPTION();
    2919. 

  2919. 			}
    2920. 

  2920. 		}
    2921. 

  2921. 		ZEND_VM_NEXT_OPCODE();
    2922. 

  2922. 	}
    2923. 

  2923. 

  2924. 	SAVE_OPLINE();
    2925. 

  2925. 	op1_type = OP1_TYPE;
    2926. 

  2926. 	if (i_zend_is_true(val)) {
    2927. 

  2927. 		opline = OP_JMP_ADDR(opline, opline->op2);
    2928. 

  2928. 	} else {
    2929. 

  2929. 		opline++;
    2930. 

  2930. 	}
    2931. 

  2931. 	if (op1_type & (IS_TMP_VAR|IS_VAR)) {
    2932. 

  2932. 		zval_ptr_dtor_nogc(val);
    2933. 

  2933. 	}
    2934. 

  2934. 	ZEND_VM_JMP(opline);
    2935. 

  2935. }
    2936. 

  2936. 

  2937. ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMPVAR|CV, JMP_ADDR, JMP_ADDR)
    2938. 

  2938. {
    2939. 

  2939. 	USE_OPLINE
    2940. 

  2940. 	zval *val;
    2941. 

  2941. 	zend_uchar op1_type;
    2942. 

  2942. 

  2943. 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    2944. 

  2944. 

  2945. 	if (EXPECTED(Z_TYPE_INFO_P(val) == IS_TRUE)) {
    2946. 

  2946. 		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
    2947. 

  2947. 		ZEND_VM_CONTINUE();
    2948. 

  2948. 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
    2949. 

  2949. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
    2950. 

  2950. 			SAVE_OPLINE();
    2951. 

  2951. 			ZVAL_UNDEFINED_OP1();
    2952. 

  2952. 			if (UNEXPECTED(EG(exception))) {
    2953. 

  2953. 				HANDLE_EXCEPTION();
    2954. 

  2954. 			}
    2955. 

  2955. 		}
    2956. 

  2956. 		ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    2957. 

  2957. 	}
    2958. 

  2958. 

  2959. 	SAVE_OPLINE();
    2960. 

  2960. 	op1_type = OP1_TYPE;
    2961. 

  2961. 	if (i_zend_is_true(val)) {
    2962. 

  2962. 		opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value);
    2963. 

  2963. 	} else {
    2964. 

  2964. 		opline = OP_JMP_ADDR(opline, opline->op2);
    2965. 

  2965. 	}
    2966. 

  2966. 	if (op1_type & (IS_TMP_VAR|IS_VAR)) {
    2967. 

  2967. 		zval_ptr_dtor_nogc(val);
    2968. 

  2968. 	}
    2969. 

  2969. 	ZEND_VM_JMP(opline);
    2970. 

  2970. }
    2971. 

  2971. 

  2972. ZEND_VM_COLD_CONST_HANDLER(46, ZEND_JMPZ_EX, CONST|TMPVAR|CV, JMP_ADDR)
    2973. 

  2973. {
    2974. 

  2974. 	USE_OPLINE
    2975. 

  2975. 	zval *val;
    2976. 

  2976. 	int ret;
    2977. 

  2977. 

  2978. 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    2979. 

  2979. 

  2980. 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
    2981. 

  2981. 		ZVAL_TRUE(EX_VAR(opline->result.var));
    2982. 

  2982. 		ZEND_VM_NEXT_OPCODE();
    2983. 

  2983. 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
    2984. 

  2984. 		ZVAL_FALSE(EX_VAR(opline->result.var));
    2985. 

  2985. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
    2986. 

  2986. 			SAVE_OPLINE();
    2987. 

  2987. 			ZVAL_UNDEFINED_OP1();
    2988. 

  2988. 			if (UNEXPECTED(EG(exception))) {
    2989. 

  2989. 				HANDLE_EXCEPTION();
    2990. 

  2990. 			}
    2991. 

  2991. 		}
    2992. 

  2992. 		ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    2993. 

  2993. 	}
    2994. 

  2994. 

  2995. 	SAVE_OPLINE();
    2996. 

  2996. 	ret = i_zend_is_true(val);
    2997. 

  2997. 	FREE_OP1();
    2998. 

  2998. 	if (ret) {
    2999. 

  2999. 		ZVAL_TRUE(EX_VAR(opline->result.var));
    3000. 

  3000. 		opline++;
    3001. 

  3001. 	} else {
    3002. 

  3002. 		ZVAL_FALSE(EX_VAR(opline->result.var));
    3003. 

  3003. 		opline = OP_JMP_ADDR(opline, opline->op2);
    3004. 

  3004. 	}
    3005. 

  3005. 	ZEND_VM_JMP(opline);
    3006. 

  3006. }
    3007. 

  3007. 

  3008. ZEND_VM_COLD_CONST_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMPVAR|CV, JMP_ADDR)
    3009. 

  3009. {
    3010. 

  3010. 	USE_OPLINE
    3011. 

  3011. 	zval *val;
    3012. 

  3012. 	int ret;
    3013. 

  3013. 

  3014. 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    3015. 

  3015. 

  3016. 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
    3017. 

  3017. 		ZVAL_TRUE(EX_VAR(opline->result.var));
    3018. 

  3018. 		ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    3019. 

  3019. 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
    3020. 

  3020. 		ZVAL_FALSE(EX_VAR(opline->result.var));
    3021. 

  3021. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
    3022. 

  3022. 			SAVE_OPLINE();
    3023. 

  3023. 			ZVAL_UNDEFINED_OP1();
    3024. 

  3024. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3025. 

  3025. 		} else {
    3026. 

  3026. 			ZEND_VM_NEXT_OPCODE();
    3027. 

  3027. 		}
    3028. 

  3028. 	}
    3029. 

  3029. 

  3030. 	SAVE_OPLINE();
    3031. 

  3031. 	ret = i_zend_is_true(val);
    3032. 

  3032. 	FREE_OP1();
    3033. 

  3033. 	if (ret) {
    3034. 

  3034. 		ZVAL_TRUE(EX_VAR(opline->result.var));
    3035. 

  3035. 		opline = OP_JMP_ADDR(opline, opline->op2);
    3036. 

  3036. 	} else {
    3037. 

  3037. 		ZVAL_FALSE(EX_VAR(opline->result.var));
    3038. 

  3038. 		opline++;
    3039. 

  3039. 	}
    3040. 

  3040. 	ZEND_VM_JMP(opline);
    3041. 

  3041. }
    3042. 

  3042. 

  3043. ZEND_VM_HANDLER(70, ZEND_FREE, TMPVAR, ANY)
    3044. 

  3044. {
    3045. 

  3045. 	USE_OPLINE
    3046. 

  3046. 

  3047. 	SAVE_OPLINE();
    3048. 

  3048. 	zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
    3049. 

  3049. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3050. 

  3050. }
    3051. 

  3051. 

  3052. ZEND_VM_HOT_HANDLER(127, ZEND_FE_FREE, TMPVAR, ANY)
    3053. 

  3053. {
    3054. 

  3054. 	zval *var;
    3055. 

  3055. 	USE_OPLINE
    3056. 

  3056. 

  3057. 	var = EX_VAR(opline->op1.var);
    3058. 

  3058. 	if (Z_TYPE_P(var) != IS_ARRAY) {
    3059. 

  3059. 		SAVE_OPLINE();
    3060. 

  3060. 		if (Z_FE_ITER_P(var) != (uint32_t)-1) {
    3061. 

  3061. 			zend_hash_iterator_del(Z_FE_ITER_P(var));
    3062. 

  3062. 		}
    3063. 

  3063. 		zval_ptr_dtor_nogc(var);
    3064. 

  3064. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3065. 

  3065. 	}
    3066. 

  3066. 

  3067. 	/* This is freeing an array. Use an inlined version of zval_ptr_dtor_nogc. */
    3068. 

  3068. 	/* PHP only needs to save the opline and check for an exception if the last reference to the array was garbage collected (destructors of elements in the array could throw an exception) */
    3069. 

  3069. 	if (Z_REFCOUNTED_P(var) && !Z_DELREF_P(var)) {
    3070. 

  3070. 		SAVE_OPLINE();
    3071. 

  3071. 		rc_dtor_func(Z_COUNTED_P(var));
    3072. 

  3072. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3073. 

  3073. 	}
    3074. 

  3074. 	ZEND_VM_NEXT_OPCODE();
    3075. 

  3075. }
    3076. 

  3076. 

  3077. ZEND_VM_COLD_CONSTCONST_HANDLER(53, ZEND_FAST_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
    3078. 

  3078. {
    3079. 

  3079. 	USE_OPLINE
    3080. 

  3080. 	zval *op1, *op2;
    3081. 

  3081. 	zend_string *op1_str, *op2_str, *str;
    3082. 

  3082. 

  3083. 

  3084. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    3085. 

  3085. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3086. 

  3086. 	if ((OP1_TYPE == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
    3087. 

  3087. 	    (OP2_TYPE == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
    3088. 

  3088. 		zend_string *op1_str = Z_STR_P(op1);
    3089. 

  3089. 		zend_string *op2_str = Z_STR_P(op2);
    3090. 

  3090. 		zend_string *str;
    3091. 

  3091. 

  3092. 		if (OP1_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
    3093. 

  3093. 			if (OP2_TYPE == IS_CONST || OP2_TYPE == IS_CV) {
    3094. 

  3094. 				ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
    3095. 

  3095. 			} else {
    3096. 

  3096. 				ZVAL_STR(EX_VAR(opline->result.var), op2_str);
    3097. 

  3097. 			}
    3098. 

  3098. 			if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    3099. 

  3099. 				zend_string_release_ex(op1_str, 0);
    3100. 

  3100. 			}
    3101. 

  3101. 		} else if (OP2_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
    3102. 

  3102. 			if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_CV) {
    3103. 

  3103. 				ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
    3104. 

  3104. 			} else {
    3105. 

  3105. 				ZVAL_STR(EX_VAR(opline->result.var), op1_str);
    3106. 

  3106. 			}
    3107. 

  3107. 			if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    3108. 

  3108. 				zend_string_release_ex(op2_str, 0);
    3109. 

  3109. 			}
    3110. 

  3110. 		} else if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
    3111. 

  3111. 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
    3112. 

  3112. 		    size_t len = ZSTR_LEN(op1_str);
    3113. 

  3113. 

  3114. 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
    3115. 

  3115. 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
    3116. 

  3116. 			ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
    3117. 

  3117. 			if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    3118. 

  3118. 				zend_string_release_ex(op2_str, 0);
    3119. 

  3119. 			}
    3120. 

  3120. 		} else {
    3121. 

  3121. 			str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
    3122. 

  3122. 			memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
    3123. 

  3123. 			memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
    3124. 

  3124. 			ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
    3125. 

  3125. 			if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    3126. 

  3126. 				zend_string_release_ex(op1_str, 0);
    3127. 

  3127. 			}
    3128. 

  3128. 			if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    3129. 

  3129. 				zend_string_release_ex(op2_str, 0);
    3130. 

  3130. 			}
    3131. 

  3131. 		}
    3132. 

  3132. 		ZEND_VM_NEXT_OPCODE();
    3133. 

  3133. 	}
    3134. 

  3134. 

  3135. 	SAVE_OPLINE();
    3136. 

  3136. 	if (OP1_TYPE == IS_CONST) {
    3137. 

  3137. 		op1_str = Z_STR_P(op1);
    3138. 

  3138. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
    3139. 

  3139. 		op1_str = zend_string_copy(Z_STR_P(op1));
    3140. 

  3140. 	} else {
    3141. 

  3141. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
    3142. 

  3142. 			ZVAL_UNDEFINED_OP1();
    3143. 

  3143. 		}
    3144. 

  3144. 		op1_str = zval_get_string_func(op1);
    3145. 

  3145. 	}
    3146. 

  3146. 	if (OP2_TYPE == IS_CONST) {
    3147. 

  3147. 		op2_str = Z_STR_P(op2);
    3148. 

  3148. 	} else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
    3149. 

  3149. 		op2_str = zend_string_copy(Z_STR_P(op2));
    3150. 

  3150. 	} else {
    3151. 

  3151. 		if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
    3152. 

  3152. 			ZVAL_UNDEFINED_OP2();
    3153. 

  3153. 		}
    3154. 

  3154. 		op2_str = zval_get_string_func(op2);
    3155. 

  3155. 	}
    3156. 

  3156. 	do {
    3157. 

  3157. 		if (OP1_TYPE != IS_CONST) {
    3158. 

  3158. 			if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
    3159. 

  3159. 				if (OP2_TYPE == IS_CONST) {
    3160. 

  3160. 					if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
    3161. 

  3161. 						GC_ADDREF(op2_str);
    3162. 

  3162. 					}
    3163. 

  3163. 				}
    3164. 

  3164. 				ZVAL_STR(EX_VAR(opline->result.var), op2_str);
    3165. 

  3165. 				zend_string_release_ex(op1_str, 0);
    3166. 

  3166. 				break;
    3167. 

  3167. 			}
    3168. 

  3168. 		}
    3169. 

  3169. 		if (OP2_TYPE != IS_CONST) {
    3170. 

  3170. 			if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
    3171. 

  3171. 				if (OP1_TYPE == IS_CONST) {
    3172. 

  3172. 					if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
    3173. 

  3173. 						GC_ADDREF(op1_str);
    3174. 

  3174. 					}
    3175. 

  3175. 				}
    3176. 

  3176. 				ZVAL_STR(EX_VAR(opline->result.var), op1_str);
    3177. 

  3177. 				zend_string_release_ex(op2_str, 0);
    3178. 

  3178. 				break;
    3179. 

  3179. 			}
    3180. 

  3180. 		}
    3181. 

  3181. 		str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
    3182. 

  3182. 		memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
    3183. 

  3183. 		memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
    3184. 

  3184. 		ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
    3185. 

  3185. 		if (OP1_TYPE != IS_CONST) {
    3186. 

  3186. 			zend_string_release_ex(op1_str, 0);
    3187. 

  3187. 		}
    3188. 

  3188. 		if (OP2_TYPE != IS_CONST) {
    3189. 

  3189. 			zend_string_release_ex(op2_str, 0);
    3190. 

  3190. 		}
    3191. 

  3191. 	} while (0);
    3192. 

  3192. 	FREE_OP1();
    3193. 

  3193. 	FREE_OP2();
    3194. 

  3194. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3195. 

  3195. }
    3196. 

  3196. 

  3197. ZEND_VM_HANDLER(54, ZEND_ROPE_INIT, UNUSED, CONST|TMPVAR|CV, NUM)
    3198. 

  3198. {
    3199. 

  3199. 	USE_OPLINE
    3200. 

  3200. 	zend_string **rope;
    3201. 

  3201. 	zval *var;
    3202. 

  3202. 

  3203. 	/* Compiler allocates the necessary number of zval slots to keep the rope */
    3204. 

  3204. 	rope = (zend_string**)EX_VAR(opline->result.var);
    3205. 

  3205. 	if (OP2_TYPE == IS_CONST) {
    3206. 

  3206. 		var = GET_OP2_ZVAL_PTR(BP_VAR_R);
    3207. 

  3207. 		rope[0] = Z_STR_P(var);
    3208. 

  3208. 		if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
    3209. 

  3209. 			Z_ADDREF_P(var);
    3210. 

  3210. 		}
    3211. 

  3211. 	} else {
    3212. 

  3212. 		var = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3213. 

  3213. 		if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
    3214. 

  3214. 			if (OP2_TYPE == IS_CV) {
    3215. 

  3215. 				rope[0] = zend_string_copy(Z_STR_P(var));
    3216. 

  3216. 			} else {
    3217. 

  3217. 				rope[0] = Z_STR_P(var);
    3218. 

  3218. 			}
    3219. 

  3219. 		} else {
    3220. 

  3220. 			SAVE_OPLINE();
    3221. 

  3221. 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
    3222. 

  3222. 				ZVAL_UNDEFINED_OP2();
    3223. 

  3223. 			}
    3224. 

  3224. 			rope[0] = zval_get_string_func(var);
    3225. 

  3225. 			FREE_OP2();
    3226. 

  3226. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3227. 

  3227. 		}
    3228. 

  3228. 	}
    3229. 

  3229. 	ZEND_VM_NEXT_OPCODE();
    3230. 

  3230. }
    3231. 

  3231. 

  3232. ZEND_VM_HANDLER(55, ZEND_ROPE_ADD, TMP, CONST|TMPVAR|CV, NUM)
    3233. 

  3233. {
    3234. 

  3234. 	USE_OPLINE
    3235. 

  3235. 	zend_string **rope;
    3236. 

  3236. 	zval *var;
    3237. 

  3237. 

  3238. 	/* op1 and result are the same */
    3239. 

  3239. 	rope = (zend_string**)EX_VAR(opline->op1.var);
    3240. 

  3240. 	if (OP2_TYPE == IS_CONST) {
    3241. 

  3241. 		var = GET_OP2_ZVAL_PTR(BP_VAR_R);
    3242. 

  3242. 		rope[opline->extended_value] = Z_STR_P(var);
    3243. 

  3243. 		if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
    3244. 

  3244. 			Z_ADDREF_P(var);
    3245. 

  3245. 		}
    3246. 

  3246. 	} else {
    3247. 

  3247. 		var = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3248. 

  3248. 		if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
    3249. 

  3249. 			if (OP2_TYPE == IS_CV) {
    3250. 

  3250. 				rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
    3251. 

  3251. 			} else {
    3252. 

  3252. 				rope[opline->extended_value] = Z_STR_P(var);
    3253. 

  3253. 			}
    3254. 

  3254. 		} else {
    3255. 

  3255. 			SAVE_OPLINE();
    3256. 

  3256. 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
    3257. 

  3257. 				ZVAL_UNDEFINED_OP2();
    3258. 

  3258. 			}
    3259. 

  3259. 			rope[opline->extended_value] = zval_get_string_func(var);
    3260. 

  3260. 			FREE_OP2();
    3261. 

  3261. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3262. 

  3262. 		}
    3263. 

  3263. 	}
    3264. 

  3264. 	ZEND_VM_NEXT_OPCODE();
    3265. 

  3265. }
    3266. 

  3266. 

  3267. ZEND_VM_HANDLER(56, ZEND_ROPE_END, TMP, CONST|TMPVAR|CV, NUM)
    3268. 

  3268. {
    3269. 

  3269. 	USE_OPLINE
    3270. 

  3270. 	zend_string **rope;
    3271. 

  3271. 	zval *var, *ret;
    3272. 

  3272. 	uint32_t i;
    3273. 

  3273. 	size_t len = 0;
    3274. 

  3274. 	char *target;
    3275. 

  3275. 

  3276. 	rope = (zend_string**)EX_VAR(opline->op1.var);
    3277. 

  3277. 	if (OP2_TYPE == IS_CONST) {
    3278. 

  3278. 		var = GET_OP2_ZVAL_PTR(BP_VAR_R);
    3279. 

  3279. 		rope[opline->extended_value] = Z_STR_P(var);
    3280. 

  3280. 		if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
    3281. 

  3281. 			Z_ADDREF_P(var);
    3282. 

  3282. 		}
    3283. 

  3283. 	} else {
    3284. 

  3284. 		var = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3285. 

  3285. 		if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
    3286. 

  3286. 			if (OP2_TYPE == IS_CV) {
    3287. 

  3287. 				rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
    3288. 

  3288. 			} else {
    3289. 

  3289. 				rope[opline->extended_value] = Z_STR_P(var);
    3290. 

  3290. 			}
    3291. 

  3291. 		} else {
    3292. 

  3292. 			SAVE_OPLINE();
    3293. 

  3293. 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
    3294. 

  3294. 				ZVAL_UNDEFINED_OP2();
    3295. 

  3295. 			}
    3296. 

  3296. 			rope[opline->extended_value] = zval_get_string_func(var);
    3297. 

  3297. 			FREE_OP2();
    3298. 

  3298. 			if (UNEXPECTED(EG(exception))) {
    3299. 

  3299. 				for (i = 0; i <= opline->extended_value; i++) {
    3300. 

  3300. 					zend_string_release_ex(rope[i], 0);
    3301. 

  3301. 				}
    3302. 

  3302. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    3303. 

  3303. 				HANDLE_EXCEPTION();
    3304. 

  3304. 			}
    3305. 

  3305. 		}
    3306. 

  3306. 	}
    3307. 

  3307. 	for (i = 0; i <= opline->extended_value; i++) {
    3308. 

  3308. 		len += ZSTR_LEN(rope[i]);
    3309. 

  3309. 	}
    3310. 

  3310. 	ret = EX_VAR(opline->result.var);
    3311. 

  3311. 	ZVAL_STR(ret, zend_string_alloc(len, 0));
    3312. 

  3312. 	target = Z_STRVAL_P(ret);
    3313. 

  3313. 	for (i = 0; i <= opline->extended_value; i++) {
    3314. 

  3314. 		memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
    3315. 

  3315. 		target += ZSTR_LEN(rope[i]);
    3316. 

  3316. 		zend_string_release_ex(rope[i], 0);
    3317. 

  3317. 	}
    3318. 

  3318. 	*target = '\0';
    3319. 

  3319. 

  3320. 	ZEND_VM_NEXT_OPCODE();
    3321. 

  3321. }
    3322. 

  3322. 

  3323. ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, UNUSED|CLASS_FETCH, CONST|TMPVAR|UNUSED|CV, CACHE_SLOT)
    3324. 

  3324. {
    3325. 

  3325. 	zval *class_name;
    3326. 

  3326. 	USE_OPLINE
    3327. 

  3327. 

  3328. 	SAVE_OPLINE();
    3329. 

  3329. 	if (OP2_TYPE == IS_UNUSED) {
    3330. 

  3330. 		Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
    3331. 

  3331. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3332. 

  3332. 	} else if (OP2_TYPE == IS_CONST) {
    3333. 

  3333. 		zend_class_entry *ce = CACHED_PTR(opline->extended_value);
    3334. 

  3334. 

  3335. 		if (UNEXPECTED(ce == NULL)) {
    3336. 

  3336. 			class_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3337. 

  3337. 			ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
    3338. 

  3338. 			CACHE_PTR(opline->extended_value, ce);
    3339. 

  3339. 		}
    3340. 

  3340. 		Z_CE_P(EX_VAR(opline->result.var)) = ce;
    3341. 

  3341. 	} else {
    3342. 

  3342. 		class_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3343. 

  3343. ZEND_VM_C_LABEL(try_class_name):
    3344. 

  3344. 		if (Z_TYPE_P(class_name) == IS_OBJECT) {
    3345. 

  3345. 			Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
    3346. 

  3346. 		} else if (Z_TYPE_P(class_name) == IS_STRING) {
    3347. 

  3347. 			Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
    3348. 

  3348. 		} else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
    3349. 

  3349. 			class_name = Z_REFVAL_P(class_name);
    3350. 

  3350. 			ZEND_VM_C_GOTO(try_class_name);
    3351. 

  3351. 		} else {
    3352. 

  3352. 			if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
    3353. 

  3353. 				ZVAL_UNDEFINED_OP2();
    3354. 

  3354. 				if (UNEXPECTED(EG(exception) != NULL)) {
    3355. 

  3355. 					HANDLE_EXCEPTION();
    3356. 

  3356. 				}
    3357. 

  3357. 			}
    3358. 

  3358. 			zend_throw_error(NULL, "Class name must be a valid object or a string");
    3359. 

  3359. 		}
    3360. 

  3360. 	}
    3361. 

  3361. 

  3362. 	FREE_OP2();
    3363. 

  3363. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3364. 

  3364. }
    3365. 

  3365. 

  3366. ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, NUM|CACHE_SLOT)
    3367. 

  3367. {
    3368. 

  3368. 	USE_OPLINE
    3369. 

  3369. 	zval *function_name;
    3370. 

  3370. 	zval *object;
    3371. 

  3371. 	zend_function *fbc;
    3372. 

  3372. 	zend_class_entry *called_scope;
    3373. 

  3373. 	zend_object *obj;
    3374. 

  3374. 	zend_execute_data *call;
    3375. 

  3375. 	uint32_t call_info;
    3376. 

  3376. 

  3377. 	SAVE_OPLINE();
    3378. 

  3378. 

  3379. 	object = GET_OP1_OBJ_ZVAL_PTR_UNDEF(BP_VAR_R);
    3380. 

  3380. 

  3381. 	if (OP2_TYPE != IS_CONST) {
    3382. 

  3382. 		function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3383. 

  3383. 	}
    3384. 

  3384. 

  3385. 	if (OP2_TYPE != IS_CONST &&
    3386. 

  3386. 	    UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
    3387. 

  3387. 		do {
    3388. 

  3388. 			if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
    3389. 

  3389. 				function_name = Z_REFVAL_P(function_name);
    3390. 

  3390. 				if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
    3391. 

  3391. 					break;
    3392. 

  3392. 				}
    3393. 

  3393. 			} else if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
    3394. 

  3394. 				ZVAL_UNDEFINED_OP2();
    3395. 

  3395. 				if (UNEXPECTED(EG(exception) != NULL)) {
    3396. 

  3396. 					FREE_OP1();
    3397. 

  3397. 					HANDLE_EXCEPTION();
    3398. 

  3398. 				}
    3399. 

  3399. 			}
    3400. 

  3400. 			zend_throw_error(NULL, "Method name must be a string");
    3401. 

  3401. 			FREE_OP2();
    3402. 

  3402. 			FREE_OP1();
    3403. 

  3403. 			HANDLE_EXCEPTION();
    3404. 

  3404. 		} while (0);
    3405. 

  3405. 	}
    3406. 

  3406. 

  3407. 	if (OP1_TYPE != IS_UNUSED) {
    3408. 

  3408. 		do {
    3409. 

  3409. 			if (OP1_TYPE == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
    3410. 

  3410. 				if ((OP1_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
    3411. 

  3411. 					object = Z_REFVAL_P(object);
    3412. 

  3412. 					if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
    3413. 

  3413. 						break;
    3414. 

  3414. 					}
    3415. 

  3415. 				}
    3416. 

  3416. 				if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
    3417. 

  3417. 					object = ZVAL_UNDEFINED_OP1();
    3418. 

  3418. 					if (UNEXPECTED(EG(exception) != NULL)) {
    3419. 

  3419. 						if (OP2_TYPE != IS_CONST) {
    3420. 

  3420. 							FREE_OP2();
    3421. 

  3421. 						}
    3422. 

  3422. 						HANDLE_EXCEPTION();
    3423. 

  3423. 					}
    3424. 

  3424. 				}
    3425. 

  3425. 				if (OP2_TYPE == IS_CONST) {
    3426. 

  3426. 					function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3427. 

  3427. 				}
    3428. 

  3428. 				zend_invalid_method_call(object, function_name);
    3429. 

  3429. 				FREE_OP2();
    3430. 

  3430. 				FREE_OP1();
    3431. 

  3431. 				HANDLE_EXCEPTION();
    3432. 

  3432. 			}
    3433. 

  3433. 		} while (0);
    3434. 

  3434. 	}
    3435. 

  3435. 

  3436. 	obj = Z_OBJ_P(object);
    3437. 

  3437. 	called_scope = obj->ce;
    3438. 

  3438. 

  3439. 	if (OP2_TYPE == IS_CONST &&
    3440. 

  3440. 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
    3441. 

  3441. 	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
    3442. 

  3442. 	} else {
    3443. 

  3443. 	    zend_object *orig_obj = obj;
    3444. 

  3444. 

  3445. 		if (OP2_TYPE == IS_CONST) {
    3446. 

  3446. 			function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3447. 

  3447. 		}
    3448. 

  3448. 

  3449. 		/* First, locate the function. */
    3450. 

  3450. 		fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
    3451. 

  3451. 		if (UNEXPECTED(fbc == NULL)) {
    3452. 

  3452. 			if (EXPECTED(!EG(exception))) {
    3453. 

  3453. 				zend_undefined_method(obj->ce, Z_STR_P(function_name));
    3454. 

  3454. 			}
    3455. 

  3455. 			FREE_OP2();
    3456. 

  3456. 			FREE_OP1();
    3457. 

  3457. 			HANDLE_EXCEPTION();
    3458. 

  3458. 		}
    3459. 

  3459. 		if (OP2_TYPE == IS_CONST &&
    3460. 

  3460. 		    EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
    3461. 

  3461. 		    EXPECTED(obj == orig_obj)) {
    3462. 

  3462. 			CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
    3463. 

  3463. 		}
    3464. 

  3464. 		if ((OP1_TYPE & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
    3465. 

  3465. 			/* Reset "object" to trigger reference counting */
    3466. 

  3466. 			object = NULL;
    3467. 

  3467. 		}
    3468. 

  3468. 		if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
    3469. 

  3469. 			init_func_run_time_cache(&fbc->op_array);
    3470. 

  3470. 		}
    3471. 

  3471. 	}
    3472. 

  3472. 

  3473. 	if (OP2_TYPE != IS_CONST) {
    3474. 

  3474. 		FREE_OP2();
    3475. 

  3475. 	}
    3476. 

  3476. 

  3477. 	call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
    3478. 

  3478. 	if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
    3479. 

  3479. 		FREE_OP1();
    3480. 

  3480. 

  3481. 		if ((OP1_TYPE & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) {
    3482. 

  3482. 			HANDLE_EXCEPTION();
    3483. 

  3483. 		}
    3484. 

  3484. 		/* call static method */
    3485. 

  3485. 		obj = (zend_object*)called_scope;
    3486. 

  3486. 		call_info = ZEND_CALL_NESTED_FUNCTION;
    3487. 

  3487. 	} else if (OP1_TYPE & (IS_VAR|IS_TMP_VAR|IS_CV)) {
    3488. 

  3488. 		if (OP1_TYPE == IS_CV) {
    3489. 

  3489. 			GC_ADDREF(obj); /* For $this pointer */
    3490. 

  3490. 		} else {
    3491. 

  3491. 			zval *free_op1 = EX_VAR(opline->op1.var);
    3492. 

  3492. 			if (free_op1 != object) {
    3493. 

  3493. 				GC_ADDREF(obj); /* For $this pointer */
    3494. 

  3494. 				zval_ptr_dtor_nogc(free_op1);
    3495. 

  3495. 			}
    3496. 

  3496. 		}
    3497. 

  3497. 		/* CV may be changed indirectly (e.g. when it's a reference) */
    3498. 

  3498. 		call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
    3499. 

  3499. 	}
    3500. 

  3500. 

  3501. 	call = zend_vm_stack_push_call_frame(call_info,
    3502. 

  3502. 		fbc, opline->extended_value, obj);
    3503. 

  3503. 	call->prev_execute_data = EX(call);
    3504. 

  3504. 	EX(call) = call;
    3505. 

  3505. 

  3506. 	ZEND_VM_NEXT_OPCODE();
    3507. 

  3507. }
    3508. 

  3508. 

  3509. ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, CONST|TMPVAR|UNUSED|CONSTRUCTOR|CV, NUM|CACHE_SLOT)
    3510. 

  3510. {
    3511. 

  3511. 	USE_OPLINE
    3512. 

  3512. 	zval *function_name;
    3513. 

  3513. 	zend_class_entry *ce;
    3514. 

  3514. 	uint32_t call_info;
    3515. 

  3515. 	zend_function *fbc;
    3516. 

  3516. 	zend_execute_data *call;
    3517. 

  3517. 

  3518. 	SAVE_OPLINE();
    3519. 

  3519. 

  3520. 	if (OP1_TYPE == IS_CONST) {
    3521. 

  3521. 		/* no function found. try a static method in class */
    3522. 

  3522. 		ce = CACHED_PTR(opline->result.num);
    3523. 

  3523. 		if (UNEXPECTED(ce == NULL)) {
    3524. 

  3524. 			ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
    3525. 

  3525. 			if (UNEXPECTED(ce == NULL)) {
    3526. 

  3526. 				ZEND_ASSERT(EG(exception));
    3527. 

  3527. 				FREE_UNFETCHED_OP2();
    3528. 

  3528. 				HANDLE_EXCEPTION();
    3529. 

  3529. 			}
    3530. 

  3530. 			if (OP2_TYPE != IS_CONST) {
    3531. 

  3531. 				CACHE_PTR(opline->result.num, ce);
    3532. 

  3532. 			}
    3533. 

  3533. 		}
    3534. 

  3534. 	} else if (OP1_TYPE == IS_UNUSED) {
    3535. 

  3535. 		ce = zend_fetch_class(NULL, opline->op1.num);
    3536. 

  3536. 		if (UNEXPECTED(ce == NULL)) {
    3537. 

  3537. 			ZEND_ASSERT(EG(exception));
    3538. 

  3538. 			FREE_UNFETCHED_OP2();
    3539. 

  3539. 			HANDLE_EXCEPTION();
    3540. 

  3540. 		}
    3541. 

  3541. 	} else {
    3542. 

  3542. 		ce = Z_CE_P(EX_VAR(opline->op1.var));
    3543. 

  3543. 	}
    3544. 

  3544. 

  3545. 	if (OP1_TYPE == IS_CONST &&
    3546. 

  3546. 	    OP2_TYPE == IS_CONST &&
    3547. 

  3547. 	    EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
    3548. 

  3548. 		/* nothing to do */
    3549. 

  3549. 	} else if (OP1_TYPE != IS_CONST &&
    3550. 

  3550. 	           OP2_TYPE == IS_CONST &&
    3551. 

  3551. 	           EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
    3552. 

  3552. 		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
    3553. 

  3553. 	} else if (OP2_TYPE != IS_UNUSED) {
    3554. 

  3554. 		function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3555. 

  3555. 		if (OP2_TYPE != IS_CONST) {
    3556. 

  3556. 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
    3557. 

  3557. 				do {
    3558. 

  3558. 					if (OP2_TYPE & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
    3559. 

  3559. 						function_name = Z_REFVAL_P(function_name);
    3560. 

  3560. 						if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
    3561. 

  3561. 							break;
    3562. 

  3562. 						}
    3563. 

  3563. 					} else if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
    3564. 

  3564. 						ZVAL_UNDEFINED_OP2();
    3565. 

  3565. 						if (UNEXPECTED(EG(exception) != NULL)) {
    3566. 

  3566. 							HANDLE_EXCEPTION();
    3567. 

  3567. 						}
    3568. 

  3568. 					}
    3569. 

  3569. 					zend_throw_error(NULL, "Method name must be a string");
    3570. 

  3570. 					FREE_OP2();
    3571. 

  3571. 					HANDLE_EXCEPTION();
    3572. 

  3572. 				} while (0);
    3573. 

  3573. 			}
    3574. 

  3574. 		}
    3575. 

  3575. 

  3576. 		if (ce->get_static_method) {
    3577. 

  3577. 			fbc = ce->get_static_method(ce, Z_STR_P(function_name));
    3578. 

  3578. 		} else {
    3579. 

  3579. 			fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
    3580. 

  3580. 		}
    3581. 

  3581. 		if (UNEXPECTED(fbc == NULL)) {
    3582. 

  3582. 			if (EXPECTED(!EG(exception))) {
    3583. 

  3583. 				zend_undefined_method(ce, Z_STR_P(function_name));
    3584. 

  3584. 			}
    3585. 

  3585. 			FREE_OP2();
    3586. 

  3586. 			HANDLE_EXCEPTION();
    3587. 

  3587. 		}
    3588. 

  3588. 		if (OP2_TYPE == IS_CONST &&
    3589. 

  3589. 		    EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
    3590. 

  3590. 			CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
    3591. 

  3591. 		}
    3592. 

  3592. 		if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
    3593. 

  3593. 			init_func_run_time_cache(&fbc->op_array);
    3594. 

  3594. 		}
    3595. 

  3595. 		if (OP2_TYPE != IS_CONST) {
    3596. 

  3596. 			FREE_OP2();
    3597. 

  3597. 		}
    3598. 

  3598. 	} else {
    3599. 

  3599. 		if (UNEXPECTED(ce->constructor == NULL)) {
    3600. 

  3600. 			zend_throw_error(NULL, "Cannot call constructor");
    3601. 

  3601. 			HANDLE_EXCEPTION();
    3602. 

  3602. 		}
    3603. 

  3603. 		if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
    3604. 

  3604. 			zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
    3605. 

  3605. 			HANDLE_EXCEPTION();
    3606. 

  3606. 		}
    3607. 

  3607. 		fbc = ce->constructor;
    3608. 

  3608. 		if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
    3609. 

  3609. 			init_func_run_time_cache(&fbc->op_array);
    3610. 

  3610. 		}
    3611. 

  3611. 	}
    3612. 

  3612. 

  3613. 	if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
    3614. 

  3614. 		if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
    3615. 

  3615. 			ce = (zend_class_entry*)Z_OBJ(EX(This));
    3616. 

  3616. 			call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
    3617. 

  3617. 		} else {
    3618. 

  3618. 			zend_non_static_method_call(fbc);
    3619. 

  3619. 			HANDLE_EXCEPTION();
    3620. 

  3620. 		}
    3621. 

  3621. 	} else {
    3622. 

  3622. 		/* previous opcode is ZEND_FETCH_CLASS */
    3623. 

  3623. 		if (OP1_TYPE == IS_UNUSED
    3624. 

  3624. 		 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
    3625. 

  3625. 		     (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
    3626. 

  3626. 			if (Z_TYPE(EX(This)) == IS_OBJECT) {
    3627. 

  3627. 				ce = Z_OBJCE(EX(This));
    3628. 

  3628. 			} else {
    3629. 

  3629. 				ce = Z_CE(EX(This));
    3630. 

  3630. 			}
    3631. 

  3631. 		}
    3632. 

  3632. 		call_info = ZEND_CALL_NESTED_FUNCTION;
    3633. 

  3633. 	}
    3634. 

  3634. 

  3635. 	call = zend_vm_stack_push_call_frame(call_info,
    3636. 

  3636. 		fbc, opline->extended_value, ce);
    3637. 

  3637. 	call->prev_execute_data = EX(call);
    3638. 

  3638. 	EX(call) = call;
    3639. 

  3639. 

  3640. 	ZEND_VM_NEXT_OPCODE();
    3641. 

  3641. }
    3642. 

  3642. 

  3643. ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT)
    3644. 

  3644. {
    3645. 

  3645. 	USE_OPLINE
    3646. 

  3646. 	zend_function *fbc;
    3647. 

  3647. 	zval *function_name, *func;
    3648. 

  3648. 	zend_execute_data *call;
    3649. 

  3649. 

  3650. 	fbc = CACHED_PTR(opline->result.num);
    3651. 

  3651. 	if (UNEXPECTED(fbc == NULL)) {
    3652. 

  3652. 		function_name = (zval*)RT_CONSTANT(opline, opline->op2);
    3653. 

  3653. 		func = zend_hash_find_ex(EG(function_table), Z_STR_P(function_name+1), 1);
    3654. 

  3654. 		if (UNEXPECTED(func == NULL)) {
    3655. 

  3655. 			ZEND_VM_DISPATCH_TO_HELPER(zend_undefined_function_helper);
    3656. 

  3656. 		}
    3657. 

  3657. 		fbc = Z_FUNC_P(func);
    3658. 

  3658. 		if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
    3659. 

  3659. 			init_func_run_time_cache(&fbc->op_array);
    3660. 

  3660. 		}
    3661. 

  3661. 		CACHE_PTR(opline->result.num, fbc);
    3662. 

  3662. 	}
    3663. 

  3663. 	call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
    3664. 

  3664. 		fbc, opline->extended_value, NULL);
    3665. 

  3665. 	call->prev_execute_data = EX(call);
    3666. 

  3666. 	EX(call) = call;
    3667. 

  3667. 

  3668. 	ZEND_VM_NEXT_OPCODE();
    3669. 

  3669. }
    3670. 

  3670. 

  3671. ZEND_VM_HANDLER(128, ZEND_INIT_DYNAMIC_CALL, ANY, CONST|TMPVAR|CV, NUM)
    3672. 

  3672. {
    3673. 

  3673. 	USE_OPLINE
    3674. 

  3674. 	zval *function_name;
    3675. 

  3675. 	zend_execute_data *call;
    3676. 

  3676. 

  3677. 	SAVE_OPLINE();
    3678. 

  3678. 	function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    3679. 

  3679. 

  3680. ZEND_VM_C_LABEL(try_function_name):
    3681. 

  3681. 	if (OP2_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
    3682. 

  3682. 		call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
    3683. 

  3683. 	} else if (OP2_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
    3684. 

  3684. 		call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
    3685. 

  3685. 	} else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
    3686. 

  3686. 		call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
    3687. 

  3687. 	} else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
    3688. 

  3688. 		function_name = Z_REFVAL_P(function_name);
    3689. 

  3689. 		ZEND_VM_C_GOTO(try_function_name);
    3690. 

  3690. 	} else {
    3691. 

  3691. 		if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
    3692. 

  3692. 			function_name = ZVAL_UNDEFINED_OP2();
    3693. 

  3693. 			if (UNEXPECTED(EG(exception) != NULL)) {
    3694. 

  3694. 				HANDLE_EXCEPTION();
    3695. 

  3695. 			}
    3696. 

  3696. 		}
    3697. 

  3697. 		zend_throw_error(NULL, "Value of type %s is not callable",
    3698. 

  3698. 			zend_get_type_by_const(Z_TYPE_P(function_name)));
    3699. 

  3699. 		call = NULL;
    3700. 

  3700. 	}
    3701. 

  3701. 

  3702. 	FREE_OP2();
    3703. 

  3703. 	if (UNEXPECTED(!call)) {
    3704. 

  3704. 		HANDLE_EXCEPTION();
    3705. 

  3705. 	}
    3706. 

  3706. 

  3707. 	if (OP2_TYPE & (IS_VAR|IS_TMP_VAR)) {
    3708. 

  3708. 		if (UNEXPECTED(EG(exception))) {
    3709. 

  3709. 			if (call) {
    3710. 

  3710. 				 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
    3711. 

  3711. 					zend_string_release_ex(call->func->common.function_name, 0);
    3712. 

  3712. 					zend_free_trampoline(call->func);
    3713. 

  3713. 				}
    3714. 

  3714. 				zend_vm_stack_free_call_frame(call);
    3715. 

  3715. 			}
    3716. 

  3716. 			HANDLE_EXCEPTION();
    3717. 

  3717. 		}
    3718. 

  3718. 	}
    3719. 

  3719. 

  3720. 	call->prev_execute_data = EX(call);
    3721. 

  3721. 	EX(call) = call;
    3722. 

  3722. 

  3723. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    3724. 

  3724. }
    3725. 

  3725. 

  3726. ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM)
    3727. 

  3727. {
    3728. 

  3728. 	USE_OPLINE
    3729. 

  3729. 	zval *function_name;
    3730. 

  3730. 	zend_fcall_info_cache fcc;
    3731. 

  3731. 	char *error = NULL;
    3732. 

  3732. 	zend_function *func;
    3733. 

  3733. 	void *object_or_called_scope;
    3734. 

  3734. 	zend_execute_data *call;
    3735. 

  3735. 	uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
    3736. 

  3736. 

  3737. 	SAVE_OPLINE();
    3738. 

  3738. 	function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
    3739. 

  3739. 	if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
    3740. 

  3740. 		ZEND_ASSERT(!error);
    3741. 

  3741. 		func = fcc.function_handler;
    3742. 

  3742. 		object_or_called_scope = fcc.called_scope;
    3743. 

  3743. 		if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
    3744. 

  3744. 			/* Delay closure destruction until its invocation */
    3745. 

  3745. 			GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
    3746. 

  3746. 			call_info |= ZEND_CALL_CLOSURE;
    3747. 

  3747. 			if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
    3748. 

  3748. 				call_info |= ZEND_CALL_FAKE_CLOSURE;
    3749. 

  3749. 			}
    3750. 

  3750. 			if (fcc.object) {
    3751. 

  3751. 				object_or_called_scope = fcc.object;
    3752. 

  3752. 				call_info |= ZEND_CALL_HAS_THIS;
    3753. 

  3753. 			}
    3754. 

  3754. 		} else if (fcc.object) {
    3755. 

  3755. 			GC_ADDREF(fcc.object); /* For $this pointer */
    3756. 

  3756. 			object_or_called_scope = fcc.object;
    3757. 

  3757. 			call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
    3758. 

  3758. 		}
    3759. 

  3759. 

  3760. 		FREE_OP2();
    3761. 

  3761. 		if ((OP2_TYPE & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
    3762. 

  3762. 			if (call_info & ZEND_CALL_CLOSURE) {
    3763. 

  3763. 				zend_object_release(ZEND_CLOSURE_OBJECT(func));
    3764. 

  3764. 			} else if (call_info & ZEND_CALL_RELEASE_THIS) {
    3765. 

  3765. 				zend_object_release(fcc.object);
    3766. 

  3766. 			}
    3767. 

  3767. 			HANDLE_EXCEPTION();
    3768. 

  3768. 		}
    3769. 

  3769. 

  3770. 		if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
    3771. 

  3771. 			init_func_run_time_cache(&func->op_array);
    3772. 

  3772. 		}
    3773. 

  3773. 	} else {
    3774. 

  3774. 		zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
    3775. 

  3775. 		efree(error);
    3776. 

  3776. 		FREE_OP2();
    3777. 

  3777. 		HANDLE_EXCEPTION();
    3778. 

  3778. 	}
    3779. 

  3779. 

  3780. 	call = zend_vm_stack_push_call_frame(call_info,
    3781. 

  3781. 		func, opline->extended_value, object_or_called_scope);
    3782. 

  3782. 	call->prev_execute_data = EX(call);
    3783. 

  3783. 	EX(call) = call;
    3784. 

  3784. 

  3785. 	ZEND_VM_NEXT_OPCODE();
    3786. 

  3786. }
    3787. 

  3787. 

  3788. ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT)
    3789. 

  3789. {
    3790. 

  3790. 	USE_OPLINE
    3791. 

  3791. 	zval *func_name;
    3792. 

  3792. 	zval *func;
    3793. 

  3793. 	zend_function *fbc;
    3794. 

  3794. 	zend_execute_data *call;
    3795. 

  3795. 

  3796. 	fbc = CACHED_PTR(opline->result.num);
    3797. 

  3797. 	if (UNEXPECTED(fbc == NULL)) {
    3798. 

  3798. 		func_name = (zval *)RT_CONSTANT(opline, opline->op2);
    3799. 

  3799. 		func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name + 1), 1);
    3800. 

  3800. 		if (func == NULL) {
    3801. 

  3801. 			func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name + 2), 1);
    3802. 

  3802. 			if (UNEXPECTED(func == NULL)) {
    3803. 

  3803. 				ZEND_VM_DISPATCH_TO_HELPER(zend_undefined_function_helper);
    3804. 

  3804. 			}
    3805. 

  3805. 		}
    3806. 

  3806. 		fbc = Z_FUNC_P(func);
    3807. 

  3807. 		if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
    3808. 

  3808. 			init_func_run_time_cache(&fbc->op_array);
    3809. 

  3809. 		}
    3810. 

  3810. 		CACHE_PTR(opline->result.num, fbc);
    3811. 

  3811. 	}
    3812. 

  3812. 

  3813. 	call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
    3814. 

  3814. 		fbc, opline->extended_value, NULL);
    3815. 

  3815. 	call->prev_execute_data = EX(call);
    3816. 

  3816. 	EX(call) = call;
    3817. 

  3817. 

  3818. 	ZEND_VM_NEXT_OPCODE();
    3819. 

  3819. }
    3820. 

  3820. 

  3821. ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT)
    3822. 

  3822. {
    3823. 

  3823. 	USE_OPLINE
    3824. 

  3824. 	zval *fname;
    3825. 

  3825. 	zval *func;
    3826. 

  3826. 	zend_function *fbc;
    3827. 

  3827. 	zend_execute_data *call;
    3828. 

  3828. 

  3829. 	fbc = CACHED_PTR(opline->result.num);
    3830. 

  3830. 	if (UNEXPECTED(fbc == NULL)) {
    3831. 

  3831. 		fname = (zval*)RT_CONSTANT(opline, opline->op2);
    3832. 

  3832. 		func = zend_hash_find_ex(EG(function_table), Z_STR_P(fname), 1);
    3833. 

  3833. 		if (UNEXPECTED(func == NULL)) {
    3834. 

  3834. 			ZEND_VM_DISPATCH_TO_HELPER(zend_undefined_function_helper);
    3835. 

  3835. 		}
    3836. 

  3836. 		fbc = Z_FUNC_P(func);
    3837. 

  3837. 		if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
    3838. 

  3838. 			init_func_run_time_cache(&fbc->op_array);
    3839. 

  3839. 		}
    3840. 

  3840. 		CACHE_PTR(opline->result.num, fbc);
    3841. 

  3841. 	}
    3842. 

  3842. 

  3843. 	call = _zend_vm_stack_push_call_frame_ex(
    3844. 

  3844. 		opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
    3845. 

  3845. 		fbc, opline->extended_value, NULL);
    3846. 

  3846. 	call->prev_execute_data = EX(call);
    3847. 

  3847. 	EX(call) = call;
    3848. 

  3848. 

  3849. 	ZEND_VM_NEXT_OPCODE();
    3850. 

  3850. }
    3851. 

  3851. 

  3852. ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL))
    3853. 

  3853. {
    3854. 

  3854. 	USE_OPLINE
    3855. 

  3855. 	zend_execute_data *call = EX(call);
    3856. 

  3856. 	zend_function *fbc = call->func;
    3857. 

  3857. 	zval *ret;
    3858. 

  3858. 	zval retval;
    3859. 

  3859. 

  3860. 	SAVE_OPLINE();
    3861. 

  3861. 	EX(call) = call->prev_execute_data;
    3862. 

  3862. 

  3863. 	call->prev_execute_data = execute_data;
    3864. 

  3864. 	EG(current_execute_data) = call;
    3865. 

  3865. 

  3866. #if ZEND_DEBUG
    3867. 

  3867. 	zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
    3868. 

  3868. #endif
    3869. 

  3869. 

  3870. 	ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
    3871. 

  3871. 	ZVAL_NULL(ret);
    3872. 

  3872. 

  3873. 	fbc->internal_function.handler(call, ret);
    3874. 

  3874. 

  3875. #if ZEND_DEBUG
    3876. 

  3876. 	if (!EG(exception) && call->func) {
    3877. 

  3877. 		if (should_throw) {
    3878. 

  3878. 			zend_internal_call_arginfo_violation(call->func);
    3879. 

  3879. 		}
    3880. 

  3880. 		ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
    3881. 

  3881. 			zend_verify_internal_return_type(call->func, ret));
    3882. 

  3882. 		ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
    3883. 

  3883. 			? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
    3884. 

  3884. 	}
    3885. 

  3885. #endif
    3886. 

  3886. 

  3887. 	EG(current_execute_data) = execute_data;
    3888. 

  3888. 	zend_vm_stack_free_args(call);
    3889. 

  3889. 	zend_vm_stack_free_call_frame(call);
    3890. 

  3890. 

  3891. 	if (!RETURN_VALUE_USED(opline)) {
    3892. 

  3892. 		i_zval_ptr_dtor(ret);
    3893. 

  3893. 	}
    3894. 

  3894. 

  3895. 	if (UNEXPECTED(EG(exception) != NULL)) {
    3896. 

  3896. 		zend_rethrow_exception(execute_data);
    3897. 

  3897. 		HANDLE_EXCEPTION();
    3898. 

  3898. 	}
    3899. 

  3899. 

  3900. 	ZEND_VM_SET_OPCODE(opline + 1);
    3901. 

  3901. 	ZEND_VM_CONTINUE();
    3902. 

  3902. }
    3903. 

  3903. 

  3904. ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL))
    3905. 

  3905. {
    3906. 

  3906. 	USE_OPLINE
    3907. 

  3907. 	zend_execute_data *call = EX(call);
    3908. 

  3908. 	zend_function *fbc = call->func;
    3909. 

  3909. 	zval *ret;
    3910. 

  3910. 

  3911. 	SAVE_OPLINE();
    3912. 

  3912. 	EX(call) = call->prev_execute_data;
    3913. 

  3913. 

  3914. 	ret = NULL;
    3915. 

  3915. 	if (RETURN_VALUE_USED(opline)) {
    3916. 

  3916. 		ret = EX_VAR(opline->result.var);
    3917. 

  3917. 	}
    3918. 

  3918. 

  3919. 	call->prev_execute_data = execute_data;
    3920. 

  3920. 	execute_data = call;
    3921. 

  3921. 	i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
    3922. 

  3922. 	LOAD_OPLINE_EX();
    3923. 

  3923. 

  3924. 	ZEND_VM_ENTER_EX();
    3925. 

  3925. }
    3926. 

  3926. 

  3927. ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL))
    3928. 

  3928. {
    3929. 

  3929. 	USE_OPLINE
    3930. 

  3930. 	zend_execute_data *call = EX(call);
    3931. 

  3931. 	zend_function *fbc = call->func;
    3932. 

  3932. 	zval *ret;
    3933. 

  3933. 

  3934. 	SAVE_OPLINE();
    3935. 

  3935. 	EX(call) = call->prev_execute_data;
    3936. 

  3936. 

  3937. 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
    3938. 

  3938. 		ret = NULL;
    3939. 

  3939. 		if (RETURN_VALUE_USED(opline)) {
    3940. 

  3940. 			ret = EX_VAR(opline->result.var);
    3941. 

  3941. 		}
    3942. 

  3942. 

  3943. 		call->prev_execute_data = execute_data;
    3944. 

  3944. 		execute_data = call;
    3945. 

  3945. 		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
    3946. 

  3946. 		LOAD_OPLINE_EX();
    3947. 

  3947. 

  3948. 		ZEND_VM_ENTER_EX();
    3949. 

  3949. 	} else {
    3950. 

  3950. 		zval retval;
    3951. 

  3951. 		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
    3952. 

  3952. 

  3953. 		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
    3954. 

  3954. 			zend_deprecated_function(fbc);
    3955. 

  3955. 			if (UNEXPECTED(EG(exception) != NULL)) {
    3956. 

  3956. 				UNDEF_RESULT();
    3957. 

  3957. 				if (!RETURN_VALUE_USED(opline)) {
    3958. 

  3958. 					ret = &retval;
    3959. 

  3959. 					ZVAL_UNDEF(ret);
    3960. 

  3960. 				}
    3961. 

  3961. 				ZEND_VM_C_GOTO(fcall_by_name_end);
    3962. 

  3962. 			}
    3963. 

  3963. 		}
    3964. 

  3964. 

  3965. 		call->prev_execute_data = execute_data;
    3966. 

  3966. 		EG(current_execute_data) = call;
    3967. 

  3967. 

  3968. #if ZEND_DEBUG
    3969. 

  3969. 		zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
    3970. 

  3970. #endif
    3971. 

  3971. 

  3972. 		ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
    3973. 

  3973. 		ZVAL_NULL(ret);
    3974. 

  3974. 

  3975. 		fbc->internal_function.handler(call, ret);
    3976. 

  3976. 

  3977. #if ZEND_DEBUG
    3978. 

  3978. 		if (!EG(exception) && call->func) {
    3979. 

  3979. 			if (should_throw) {
    3980. 

  3980. 				zend_internal_call_arginfo_violation(call->func);
    3981. 

  3981. 			}
    3982. 

  3982. 			ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
    3983. 

  3983. 				zend_verify_internal_return_type(call->func, ret));
    3984. 

  3984. 			ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
    3985. 

  3985. 				? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
    3986. 

  3986. 		}
    3987. 

  3987. #endif
    3988. 

  3988. 

  3989. 		EG(current_execute_data) = execute_data;
    3990. 

  3990. 

  3991. ZEND_VM_C_LABEL(fcall_by_name_end):
    3992. 

  3992. 		zend_vm_stack_free_args(call);
    3993. 

  3993. 		zend_vm_stack_free_call_frame(call);
    3994. 

  3994. 

  3995. 		if (!RETURN_VALUE_USED(opline)) {
    3996. 

  3996. 			i_zval_ptr_dtor(ret);
    3997. 

  3997. 		}
    3998. 

  3998. 	}
    3999. 

  3999. 

  4000. 	if (UNEXPECTED(EG(exception) != NULL)) {
    4001. 

  4001. 		zend_rethrow_exception(execute_data);
    4002. 

  4002. 		HANDLE_EXCEPTION();
    4003. 

  4003. 	}
    4004. 

  4004. 	ZEND_VM_SET_OPCODE(opline + 1);
    4005. 

  4005. 	ZEND_VM_CONTINUE();
    4006. 

  4006. }
    4007. 

  4007. 

  4008. ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL))
    4009. 

  4009. {
    4010. 

  4010. 	USE_OPLINE
    4011. 

  4011. 	zend_execute_data *call = EX(call);
    4012. 

  4012. 	zend_function *fbc = call->func;
    4013. 

  4013. 	zval *ret;
    4014. 

  4014. 

  4015. 	SAVE_OPLINE();
    4016. 

  4016. 	EX(call) = call->prev_execute_data;
    4017. 

  4017. 

  4018. 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
    4019. 

  4019. 		ret = NULL;
    4020. 

  4020. 		if (RETURN_VALUE_USED(opline)) {
    4021. 

  4021. 			ret = EX_VAR(opline->result.var);
    4022. 

  4022. 		}
    4023. 

  4023. 

  4024. 		call->prev_execute_data = execute_data;
    4025. 

  4025. 		execute_data = call;
    4026. 

  4026. 		i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
    4027. 

  4027. 

  4028. 		if (EXPECTED(zend_execute_ex == execute_ex)) {
    4029. 

  4029. 			LOAD_OPLINE_EX();
    4030. 

  4030. 			ZEND_VM_ENTER_EX();
    4031. 

  4031. 		} else {
    4032. 

  4032. 			SAVE_OPLINE_EX();
    4033. 

  4033. 			execute_data = EX(prev_execute_data);
    4034. 

  4034. 			LOAD_OPLINE();
    4035. 

  4035. 			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
    4036. 

  4036. 			zend_execute_ex(call);
    4037. 

  4037. 		}
    4038. 

  4038. 	} else {
    4039. 

  4039. 		zval retval;
    4040. 

  4040. 		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
    4041. 

  4041. 

  4042. 		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
    4043. 

  4043. 			zend_deprecated_function(fbc);
    4044. 

  4044. 			if (UNEXPECTED(EG(exception) != NULL)) {
    4045. 

  4045. 				UNDEF_RESULT();
    4046. 

  4046. 				if (!RETURN_VALUE_USED(opline)) {
    4047. 

  4047. 					ret = &retval;
    4048. 

  4048. 					ZVAL_UNDEF(ret);
    4049. 

  4049. 				}
    4050. 

  4050. 				ZEND_VM_C_GOTO(fcall_end);
    4051. 

  4051. 			}
    4052. 

  4052. 		}
    4053. 

  4053. 

  4054. 		call->prev_execute_data = execute_data;
    4055. 

  4055. 		EG(current_execute_data) = call;
    4056. 

  4056. 

  4057. #if ZEND_DEBUG
    4058. 

  4058. 		zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
    4059. 

  4059. #endif
    4060. 

  4060. 

  4061. 		ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
    4062. 

  4062. 		ZVAL_NULL(ret);
    4063. 

  4063. 

  4064. 		if (!zend_execute_internal) {
    4065. 

  4065. 			/* saves one function call if zend_execute_internal is not used */
    4066. 

  4066. 			fbc->internal_function.handler(call, ret);
    4067. 

  4067. 		} else {
    4068. 

  4068. 			zend_execute_internal(call, ret);
    4069. 

  4069. 		}
    4070. 

  4070. 

  4071. #if ZEND_DEBUG
    4072. 

  4072. 		if (!EG(exception) && call->func) {
    4073. 

  4073. 			if (should_throw) {
    4074. 

  4074. 				zend_internal_call_arginfo_violation(call->func);
    4075. 

  4075. 			}
    4076. 

  4076. 			ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
    4077. 

  4077. 				zend_verify_internal_return_type(call->func, ret));
    4078. 

  4078. 			ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
    4079. 

  4079. 				? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
    4080. 

  4080. 		}
    4081. 

  4081. #endif
    4082. 

  4082. 

  4083. 		EG(current_execute_data) = execute_data;
    4084. 

  4084. 

  4085. ZEND_VM_C_LABEL(fcall_end):
    4086. 

  4086. 		zend_vm_stack_free_args(call);
    4087. 

  4087. 		if (!RETURN_VALUE_USED(opline)) {
    4088. 

  4088. 			i_zval_ptr_dtor(ret);
    4089. 

  4089. 		}
    4090. 

  4090. 	}
    4091. 

  4091. 

  4092. 	if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
    4093. 

  4093. 		OBJ_RELEASE(Z_OBJ(call->This));
    4094. 

  4094. 	}
    4095. 

  4095. 

  4096. 	zend_vm_stack_free_call_frame(call);
    4097. 

  4097. 	if (UNEXPECTED(EG(exception) != NULL)) {
    4098. 

  4098. 		zend_rethrow_exception(execute_data);
    4099. 

  4099. 		HANDLE_EXCEPTION();
    4100. 

  4100. 	}
    4101. 

  4101. 

  4102. 	ZEND_VM_SET_OPCODE(opline + 1);
    4103. 

  4103. 	ZEND_VM_CONTINUE();
    4104. 

  4104. }
    4105. 

  4105. 

  4106. ZEND_VM_COLD_CONST_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED|CACHE_SLOT)
    4107. 

  4107. {
    4108. 

  4108. 	USE_OPLINE
    4109. 

  4109. 

  4110. 	if (OP1_TYPE == IS_UNUSED) {
    4111. 

  4111. 		SAVE_OPLINE();
    4112. 

  4112. 		zend_verify_missing_return_type(EX(func), CACHE_ADDR(opline->op2.num));
    4113. 

  4113. 		HANDLE_EXCEPTION();
    4114. 

  4114. 	} else {
    4115. 

  4115. /* prevents "undefined variable opline" errors */
    4116. 

  4116. #if !ZEND_VM_SPEC || (OP1_TYPE != IS_UNUSED)
    4117. 

  4117. 		zval *retval_ref, *retval_ptr;
    4118. 

  4118. 		zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
    4119. 

  4119. 		retval_ref = retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4120. 

  4120. 

  4121. 		if (OP1_TYPE == IS_CONST) {
    4122. 

  4122. 			ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
    4123. 

  4123. 			retval_ref = retval_ptr = EX_VAR(opline->result.var);
    4124. 

  4124. 		} else if (OP1_TYPE == IS_VAR) {
    4125. 

  4125. 			if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
    4126. 

  4126. 				retval_ptr = Z_INDIRECT_P(retval_ptr);
    4127. 

  4127. 			}
    4128. 

  4128. 			ZVAL_DEREF(retval_ptr);
    4129. 

  4129. 		} else if (OP1_TYPE == IS_CV) {
    4130. 

  4130. 			ZVAL_DEREF(retval_ptr);
    4131. 

  4131. 		}
    4132. 

  4132. 

  4133. 		if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
    4134. 

  4134. 			ZEND_VM_NEXT_OPCODE();
    4135. 

  4135. 		}
    4136. 

  4136. 

  4137. 		zend_reference *ref = NULL;
    4138. 

  4138. 		void *cache_slot = CACHE_ADDR(opline->op2.num);
    4139. 

  4139. 		if (UNEXPECTED(retval_ref != retval_ptr)) {
    4140. 

  4140. 			if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
    4141. 

  4141. 				ref = Z_REF_P(retval_ref);
    4142. 

  4142. 			} else {
    4143. 

  4143. 				/* A cast might happen - unwrap the reference if this is a by-value return */
    4144. 

  4144. 				if (Z_REFCOUNT_P(retval_ref) == 1) {
    4145. 

  4145. 					ZVAL_UNREF(retval_ref);
    4146. 

  4146. 				} else {
    4147. 

  4147. 					Z_DELREF_P(retval_ref);
    4148. 

  4148. 					ZVAL_COPY(retval_ref, retval_ptr);
    4149. 

  4149. 				}
    4150. 

  4150. 				retval_ptr = retval_ref;
    4151. 

  4151. 			}
    4152. 

  4152. 		}
    4153. 

  4153. 

  4154. 		SAVE_OPLINE();
    4155. 

  4155. 		if (UNEXPECTED(!zend_check_type_slow(ret_info->type, retval_ptr, ref, cache_slot, NULL, 1, 0))) {
    4156. 

  4156. 			zend_verify_return_error(EX(func), cache_slot, retval_ptr);
    4157. 

  4157. 			HANDLE_EXCEPTION();
    4158. 

  4158. 		}
    4159. 

  4159. 		ZEND_VM_NEXT_OPCODE();
    4160. 

  4160. #endif
    4161. 

  4161. 	}
    4162. 

  4162. }
    4163. 

  4163. 

  4164. ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
    4165. 

  4165. {
    4166. 

  4166. 	USE_OPLINE
    4167. 

  4167. 	zval *retval_ptr;
    4168. 

  4168. 	zval *return_value;
    4169. 

  4169. 

  4170. 	retval_ptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    4171. 

  4171. 	return_value = EX(return_value);
    4172. 

  4172. 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
    4173. 

  4173. 		SAVE_OPLINE();
    4174. 

  4174. 		retval_ptr = ZVAL_UNDEFINED_OP1();
    4175. 

  4175. 		if (return_value) {
    4176. 

  4176. 			ZVAL_NULL(return_value);
    4177. 

  4177. 		}
    4178. 

  4178. 	} else if (!return_value) {
    4179. 

  4179. 		if (OP1_TYPE & (IS_VAR|IS_TMP_VAR)) {
    4180. 

  4180. 			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
    4181. 

  4181. 				SAVE_OPLINE();
    4182. 

  4182. 				rc_dtor_func(Z_COUNTED_P(retval_ptr));
    4183. 

  4183. 			}
    4184. 

  4184. 		}
    4185. 

  4185. 	} else {
    4186. 

  4186. 		if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) {
    4187. 

  4187. 			ZVAL_COPY_VALUE(return_value, retval_ptr);
    4188. 

  4188. 			if (OP1_TYPE == IS_CONST) {
    4189. 

  4189. 				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
    4190. 

  4190. 					Z_ADDREF_P(return_value);
    4191. 

  4191. 				}
    4192. 

  4192. 			}
    4193. 

  4193. 		} else if (OP1_TYPE == IS_CV) {
    4194. 

  4194. 			do {
    4195. 

  4195. 				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
    4196. 

  4196. 					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
    4197. 

  4197. 						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
    4198. 

  4198. 							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
    4199. 

  4199. 							ZVAL_COPY_VALUE(return_value, retval_ptr);
    4200. 

  4200. 							if (GC_MAY_LEAK(ref)) {
    4201. 

  4201. 								gc_possible_root(ref);
    4202. 

  4202. 							}
    4203. 

  4203. 							ZVAL_NULL(retval_ptr);
    4204. 

  4204. 							break;
    4205. 

  4205. 						} else {
    4206. 

  4206. 							Z_ADDREF_P(retval_ptr);
    4207. 

  4207. 						}
    4208. 

  4208. 					} else {
    4209. 

  4209. 						retval_ptr = Z_REFVAL_P(retval_ptr);
    4210. 

  4210. 						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
    4211. 

  4211. 							Z_ADDREF_P(retval_ptr);
    4212. 

  4212. 						}
    4213. 

  4213. 					}
    4214. 

  4214. 				}
    4215. 

  4215. 				ZVAL_COPY_VALUE(return_value, retval_ptr);
    4216. 

  4216. 			} while (0);
    4217. 

  4217. 		} else /* if (OP1_TYPE == IS_VAR) */ {
    4218. 

  4218. 			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
    4219. 

  4219. 				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
    4220. 

  4220. 

  4221. 				retval_ptr = Z_REFVAL_P(retval_ptr);
    4222. 

  4222. 				ZVAL_COPY_VALUE(return_value, retval_ptr);
    4223. 

  4223. 				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
    4224. 

  4224. 					efree_size(ref, sizeof(zend_reference));
    4225. 

  4225. 				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
    4226. 

  4226. 					Z_ADDREF_P(retval_ptr);
    4227. 

  4227. 				}
    4228. 

  4228. 			} else {
    4229. 

  4229. 				ZVAL_COPY_VALUE(return_value, retval_ptr);
    4230. 

  4230. 			}
    4231. 

  4231. 		}
    4232. 

  4232. 	}
    4233. 

  4233. 	ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
    4234. 

  4234. }
    4235. 

  4235. 

  4236. ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC)
    4237. 

  4237. {
    4238. 

  4238. 	USE_OPLINE
    4239. 

  4239. 	zval *retval_ptr;
    4240. 

  4240. 

  4241. 	SAVE_OPLINE();
    4242. 

  4242. 

  4243. 	do {
    4244. 

  4244. 		if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR)) ||
    4245. 

  4245. 		    (OP1_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
    4246. 

  4246. 			/* Not supposed to happen, but we'll allow it */
    4247. 

  4247. 			zend_error(E_NOTICE, "Only variable references should be returned by reference");
    4248. 

  4248. 

  4249. 			retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4250. 

  4250. 			if (!EX(return_value)) {
    4251. 

  4251. 				FREE_OP1();
    4252. 

  4252. 			} else {
    4253. 

  4253. 				if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
    4254. 

  4254. 					ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
    4255. 

  4255. 					break;
    4256. 

  4256. 				}
    4257. 

  4257. 

  4258. 				ZVAL_NEW_REF(EX(return_value), retval_ptr);
    4259. 

  4259. 				if (OP1_TYPE == IS_CONST) {
    4260. 

  4260. 					Z_TRY_ADDREF_P(retval_ptr);
    4261. 

  4261. 				}
    4262. 

  4262. 			}
    4263. 

  4263. 			break;
    4264. 

  4264. 		}
    4265. 

  4265. 

  4266. 		retval_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
    4267. 

  4267. 

  4268. 		if (OP1_TYPE == IS_VAR) {
    4269. 

  4269. 			ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
    4270. 

  4270. 			if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
    4271. 

  4271. 				zend_error(E_NOTICE, "Only variable references should be returned by reference");
    4272. 

  4272. 				if (EX(return_value)) {
    4273. 

  4273. 					ZVAL_NEW_REF(EX(return_value), retval_ptr);
    4274. 

  4274. 				} else {
    4275. 

  4275. 					FREE_OP1_VAR_PTR();
    4276. 

  4276. 				}
    4277. 

  4277. 				break;
    4278. 

  4278. 			}
    4279. 

  4279. 		}
    4280. 

  4280. 

  4281. 		if (EX(return_value)) {
    4282. 

  4282. 			if (Z_ISREF_P(retval_ptr)) {
    4283. 

  4283. 				Z_ADDREF_P(retval_ptr);
    4284. 

  4284. 			} else {
    4285. 

  4285. 				ZVAL_MAKE_REF_EX(retval_ptr, 2);
    4286. 

  4286. 			}
    4287. 

  4287. 			ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
    4288. 

  4288. 		}
    4289. 

  4289. 

  4290. 		FREE_OP1_VAR_PTR();
    4291. 

  4291. 	} while (0);
    4292. 

  4292. 

  4293. 	ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
    4294. 

  4294. }
    4295. 

  4295. 

  4296. ZEND_VM_HANDLER(139, ZEND_GENERATOR_CREATE, ANY, ANY)
    4297. 

  4297. {
    4298. 

  4298. 	zval *return_value = EX(return_value);
    4299. 

  4299. 

  4300. 	if (EXPECTED(return_value)) {
    4301. 

  4301. 		USE_OPLINE
    4302. 

  4302. 		zend_generator *generator;
    4303. 

  4303. 		zend_execute_data *gen_execute_data;
    4304. 

  4304. 		uint32_t num_args, used_stack, call_info;
    4305. 

  4305. 

  4306. 		object_init_ex(return_value, zend_ce_generator);
    4307. 

  4307. 

  4308. 		/*
    4309. 

  4309. 		 * Normally the execute_data is allocated on the VM stack (because it does
    4310. 

  4310. 		 * not actually do any allocation and thus is faster). For generators
    4311. 

  4311. 		 * though this behavior would be suboptimal, because the (rather large)
    4312. 

  4312. 		 * structure would have to be copied back and forth every time execution is
    4313. 

  4313. 		 * suspended or resumed. That's why for generators the execution context
    4314. 

  4314. 		 * is allocated on heap.
    4315. 

  4315. 		 */
    4316. 

  4316. 		num_args = EX_NUM_ARGS();
    4317. 

  4317. 		if (EXPECTED(num_args <= EX(func)->op_array.num_args)) {
    4318. 

  4318. 			used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var + EX(func)->op_array.T) * sizeof(zval);
    4319. 

  4319. 			gen_execute_data = (zend_execute_data*)emalloc(used_stack);
    4320. 

  4320. 			used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var) * sizeof(zval);
    4321. 

  4321. 		} else {
    4322. 

  4322. 			used_stack = (ZEND_CALL_FRAME_SLOT + num_args + EX(func)->op_array.last_var + EX(func)->op_array.T - EX(func)->op_array.num_args) * sizeof(zval);
    4323. 

  4323. 			gen_execute_data = (zend_execute_data*)emalloc(used_stack);
    4324. 

  4324. 		}
    4325. 

  4325. 		memcpy(gen_execute_data, execute_data, used_stack);
    4326. 

  4326. 

  4327. 		/* Save execution context in generator object. */
    4328. 

  4328. 		generator = (zend_generator *) Z_OBJ_P(EX(return_value));
    4329. 

  4329. 		generator->execute_data = gen_execute_data;
    4330. 

  4330. 		generator->frozen_call_stack = NULL;
    4331. 

  4331. 		generator->execute_fake.opline = NULL;
    4332. 

  4332. 		generator->execute_fake.func = NULL;
    4333. 

  4333. 		generator->execute_fake.prev_execute_data = NULL;
    4334. 

  4334. 		ZVAL_OBJ(&generator->execute_fake.This, (zend_object *) generator);
    4335. 

  4335. 

  4336. 		gen_execute_data->opline = opline + 1;
    4337. 

  4337. 		/* EX(return_value) keeps pointer to zend_object (not a real zval) */
    4338. 

  4338. 		gen_execute_data->return_value = (zval*)generator;
    4339. 

  4339. 		call_info = Z_TYPE_INFO(EX(This));
    4340. 

  4340. 		if ((call_info & Z_TYPE_MASK) == IS_OBJECT
    4341. 

  4341. 		 && (!(call_info & (ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS))
    4342. 

  4342. 			 /* Bug #72523 */
    4343. 

  4343. 			|| UNEXPECTED(zend_execute_ex != execute_ex))) {
    4344. 

  4344. 			ZEND_ADD_CALL_FLAG_EX(call_info, ZEND_CALL_RELEASE_THIS);
    4345. 

  4345. 			Z_ADDREF(gen_execute_data->This);
    4346. 

  4346. 		}
    4347. 

  4347. 		ZEND_ADD_CALL_FLAG_EX(call_info, (ZEND_CALL_TOP_FUNCTION | ZEND_CALL_ALLOCATED | ZEND_CALL_GENERATOR));
    4348. 

  4348. 		Z_TYPE_INFO(gen_execute_data->This) = call_info;
    4349. 

  4349. 		gen_execute_data->prev_execute_data = NULL;
    4350. 

  4350. 

  4351. 		call_info = EX_CALL_INFO();
    4352. 

  4352. 		EG(current_execute_data) = EX(prev_execute_data);
    4353. 

  4353. 		if (EXPECTED(!(call_info & (ZEND_CALL_TOP|ZEND_CALL_ALLOCATED)))) {
    4354. 

  4354. 			EG(vm_stack_top) = (zval*)execute_data;
    4355. 

  4355. 			execute_data = EX(prev_execute_data);
    4356. 

  4356. 			LOAD_NEXT_OPLINE();
    4357. 

  4357. 			ZEND_VM_LEAVE();
    4358. 

  4358. 		} else if (EXPECTED(!(call_info & ZEND_CALL_TOP))) {
    4359. 

  4359. 			zend_execute_data *old_execute_data = execute_data;
    4360. 

  4360. 			execute_data = EX(prev_execute_data);
    4361. 

  4361. 			zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
    4362. 

  4362. 			LOAD_NEXT_OPLINE();
    4363. 

  4363. 			ZEND_VM_LEAVE();
    4364. 

  4364. 		} else {
    4365. 

  4365. 			ZEND_VM_RETURN();
    4366. 

  4366. 		}
    4367. 

  4367. 	} else {
    4368. 

  4368. 		ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
    4369. 

  4369. 	}
    4370. 

  4370. }
    4371. 

  4371. 

  4372. ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY)
    4373. 

  4373. {
    4374. 

  4374. 	USE_OPLINE
    4375. 

  4375. 	zval *retval;
    4376. 

  4376. 

  4377. 	zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
    4378. 

  4378. 

  4379. 	SAVE_OPLINE();
    4380. 

  4380. 	retval = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4381. 

  4381. 

  4382. 	/* Copy return value into generator->retval */
    4383. 

  4383. 	if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) {
    4384. 

  4384. 		ZVAL_COPY_VALUE(&generator->retval, retval);
    4385. 

  4385. 		if (OP1_TYPE == IS_CONST) {
    4386. 

  4386. 			if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
    4387. 

  4387. 				Z_ADDREF(generator->retval);
    4388. 

  4388. 			}
    4389. 

  4389. 		}
    4390. 

  4390. 	} else if (OP1_TYPE == IS_CV) {
    4391. 

  4391. 		ZVAL_COPY_DEREF(&generator->retval, retval);
    4392. 

  4392. 	} else /* if (OP1_TYPE == IS_VAR) */ {
    4393. 

  4393. 		if (UNEXPECTED(Z_ISREF_P(retval))) {
    4394. 

  4394. 			zend_refcounted *ref = Z_COUNTED_P(retval);
    4395. 

  4395. 

  4396. 			retval = Z_REFVAL_P(retval);
    4397. 

  4397. 			ZVAL_COPY_VALUE(&generator->retval, retval);
    4398. 

  4398. 			if (UNEXPECTED(GC_DELREF(ref) == 0)) {
    4399. 

  4399. 				efree_size(ref, sizeof(zend_reference));
    4400. 

  4400. 			} else if (Z_OPT_REFCOUNTED_P(retval)) {
    4401. 

  4401. 				Z_ADDREF_P(retval);
    4402. 

  4402. 			}
    4403. 

  4403. 		} else {
    4404. 

  4404. 			ZVAL_COPY_VALUE(&generator->retval, retval);
    4405. 

  4405. 		}
    4406. 

  4406. 	}
    4407. 

  4407. 

  4408. 	/* Close the generator to free up resources */
    4409. 

  4409. 	zend_generator_close(generator, 1);
    4410. 

  4410. 

  4411. 	/* Pass execution back to handling code */
    4412. 

  4412. 	ZEND_VM_RETURN();
    4413. 

  4413. }
    4414. 

  4414. 

  4415. ZEND_VM_COLD_CONST_HANDLER(108, ZEND_THROW, CONST|TMPVAR|CV, ANY)
    4416. 

  4416. {
    4417. 

  4417. 	USE_OPLINE
    4418. 

  4418. 	zval *value;
    4419. 

  4419. 

  4420. 	SAVE_OPLINE();
    4421. 

  4421. 	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    4422. 

  4422. 

  4423. 	do {
    4424. 

  4424. 		if (OP1_TYPE == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
    4425. 

  4425. 			if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
    4426. 

  4426. 				value = Z_REFVAL_P(value);
    4427. 

  4427. 				if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
    4428. 

  4428. 					break;
    4429. 

  4429. 				}
    4430. 

  4430. 			}
    4431. 

  4431. 			if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
    4432. 

  4432. 				ZVAL_UNDEFINED_OP1();
    4433. 

  4433. 				if (UNEXPECTED(EG(exception) != NULL)) {
    4434. 

  4434. 					HANDLE_EXCEPTION();
    4435. 

  4435. 				}
    4436. 

  4436. 			}
    4437. 

  4437. 			zend_throw_error(NULL, "Can only throw objects");
    4438. 

  4438. 			FREE_OP1();
    4439. 

  4439. 			HANDLE_EXCEPTION();
    4440. 

  4440. 		}
    4441. 

  4441. 	} while (0);
    4442. 

  4442. 

  4443. 	zend_exception_save();
    4444. 

  4444. 	Z_TRY_ADDREF_P(value);
    4445. 

  4445. 	zend_throw_exception_object(value);
    4446. 

  4446. 	zend_exception_restore();
    4447. 

  4447. 	FREE_OP1();
    4448. 

  4448. 	HANDLE_EXCEPTION();
    4449. 

  4449. }
    4450. 

  4450. 

  4451. ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, JMP_ADDR, LAST_CATCH|CACHE_SLOT)
    4452. 

  4452. {
    4453. 

  4453. 	USE_OPLINE
    4454. 

  4454. 	zend_class_entry *ce, *catch_ce;
    4455. 

  4455. 	zend_object *exception;
    4456. 

  4456. 	zval *ex;
    4457. 

  4457. 

  4458. 	SAVE_OPLINE();
    4459. 

  4459. 	/* Check whether an exception has been thrown, if not, jump over code */
    4460. 

  4460. 	zend_exception_restore();
    4461. 

  4461. 	if (EG(exception) == NULL) {
    4462. 

  4462. 		ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    4463. 

  4463. 	}
    4464. 

  4464. 	catch_ce = CACHED_PTR(opline->extended_value & ~ZEND_LAST_CATCH);
    4465. 

  4465. 	if (UNEXPECTED(catch_ce == NULL)) {
    4466. 

  4466. 		catch_ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD);
    4467. 

  4467. 

  4468. 		CACHE_PTR(opline->extended_value & ~ZEND_LAST_CATCH, catch_ce);
    4469. 

  4469. 	}
    4470. 

  4470. 	ce = EG(exception)->ce;
    4471. 

  4471. 

  4472. #ifdef HAVE_DTRACE
    4473. 

  4473. 	if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
    4474. 

  4474. 		DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
    4475. 

  4475. 	}
    4476. 

  4476. #endif /* HAVE_DTRACE */
    4477. 

  4477. 

  4478. 	if (ce != catch_ce) {
    4479. 

  4479. 		if (!catch_ce || !instanceof_function(ce, catch_ce)) {
    4480. 

  4480. 			if (opline->extended_value & ZEND_LAST_CATCH) {
    4481. 

  4481. 				zend_rethrow_exception(execute_data);
    4482. 

  4482. 				HANDLE_EXCEPTION();
    4483. 

  4483. 			}
    4484. 

  4484. 			ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    4485. 

  4485. 		}
    4486. 

  4486. 	}
    4487. 

  4487. 

  4488. 	exception = EG(exception);
    4489. 

  4489. 	ex = EX_VAR(opline->result.var);
    4490. 

  4490. 	if (UNEXPECTED(Z_ISREF_P(ex))) {
    4491. 

  4491. 		ex = Z_REFVAL_P(ex);
    4492. 

  4492. 	}
    4493. 

  4493. 	zval_ptr_dtor(ex);
    4494. 

  4494. 	ZVAL_OBJ(ex, EG(exception));
    4495. 

  4495. 	if (UNEXPECTED(EG(exception) != exception)) {
    4496. 

  4496. 		GC_ADDREF(EG(exception));
    4497. 

  4497. 		HANDLE_EXCEPTION();
    4498. 

  4498. 	} else {
    4499. 

  4499. 		EG(exception) = NULL;
    4500. 

  4500. 		ZEND_VM_NEXT_OPCODE();
    4501. 

  4501. 	}
    4502. 

  4502. }
    4503. 

  4503. 

  4504. ZEND_VM_HOT_HANDLER(65, ZEND_SEND_VAL, CONST|TMPVAR, NUM)
    4505. 

  4505. {
    4506. 

  4506. 	USE_OPLINE
    4507. 

  4507. 	zval *value, *arg;
    4508. 

  4508. 

  4509. 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4510. 

  4510. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4511. 

  4511. 	ZVAL_COPY_VALUE(arg, value);
    4512. 

  4512. 	if (OP1_TYPE == IS_CONST) {
    4513. 

  4513. 		if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
    4514. 

  4514. 			Z_ADDREF_P(arg);
    4515. 

  4515. 		}
    4516. 

  4516. 	}
    4517. 

  4517. 	ZEND_VM_NEXT_OPCODE();
    4518. 

  4518. }
    4519. 

  4519. 

  4520. ZEND_VM_COLD_HELPER(zend_cannot_pass_by_ref_helper, ANY, ANY)
    4521. 

  4521. {
    4522. 

  4522. 	USE_OPLINE
    4523. 

  4523. 	zval *arg;
    4524. 

  4524. 	uint32_t arg_num = opline->op2.num;
    4525. 

  4525. 

  4526. 	SAVE_OPLINE();
    4527. 

  4527. 	zend_throw_error(NULL, "Cannot pass parameter %d by reference", arg_num);
    4528. 

  4528. 	FREE_UNFETCHED_OP1();
    4529. 

  4529. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4530. 

  4530. 	ZVAL_UNDEF(arg);
    4531. 

  4531. 	HANDLE_EXCEPTION();
    4532. 

  4532. }
    4533. 

  4533. 

  4534. ZEND_VM_HOT_SEND_HANDLER(116, ZEND_SEND_VAL_EX, CONST|TMP, NUM, SPEC(QUICK_ARG))
    4535. 

  4535. {
    4536. 

  4536. 	USE_OPLINE
    4537. 

  4537. 	zval *value, *arg;
    4538. 

  4538. 	uint32_t arg_num = opline->op2.num;
    4539. 

  4539. 

  4540. 	if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
    4541. 

  4541. 		if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4542. 

  4542. 			ZEND_VM_C_GOTO(send_val_by_ref);
    4543. 

  4543. 		}
    4544. 

  4544. 	} else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4545. 

  4545. ZEND_VM_C_LABEL(send_val_by_ref):
    4546. 

  4546. 		ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper);
    4547. 

  4547. 	}
    4548. 

  4548. 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4549. 

  4549. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4550. 

  4550. 	ZVAL_COPY_VALUE(arg, value);
    4551. 

  4551. 	if (OP1_TYPE == IS_CONST) {
    4552. 

  4552. 		if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
    4553. 

  4553. 			Z_ADDREF_P(arg);
    4554. 

  4554. 		}
    4555. 

  4555. 	}
    4556. 

  4556. 	ZEND_VM_NEXT_OPCODE();
    4557. 

  4557. }
    4558. 

  4558. 

  4559. ZEND_VM_HOT_HANDLER(117, ZEND_SEND_VAR, VAR|CV, NUM)
    4560. 

  4560. {
    4561. 

  4561. 	USE_OPLINE
    4562. 

  4562. 	zval *varptr, *arg;
    4563. 

  4563. 

  4564. 	varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    4565. 

  4565. 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
    4566. 

  4566. 		SAVE_OPLINE();
    4567. 

  4567. 		ZVAL_UNDEFINED_OP1();
    4568. 

  4568. 		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4569. 

  4569. 		ZVAL_NULL(arg);
    4570. 

  4570. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    4571. 

  4571. 	}
    4572. 

  4572. 

  4573. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4574. 

  4574. 

  4575. 	if (OP1_TYPE == IS_CV) {
    4576. 

  4576. 		ZVAL_COPY_DEREF(arg, varptr);
    4577. 

  4577. 	} else /* if (OP1_TYPE == IS_VAR) */ {
    4578. 

  4578. 		if (UNEXPECTED(Z_ISREF_P(varptr))) {
    4579. 

  4579. 			zend_refcounted *ref = Z_COUNTED_P(varptr);
    4580. 

  4580. 

  4581. 			varptr = Z_REFVAL_P(varptr);
    4582. 

  4582. 			ZVAL_COPY_VALUE(arg, varptr);
    4583. 

  4583. 			if (UNEXPECTED(GC_DELREF(ref) == 0)) {
    4584. 

  4584. 				efree_size(ref, sizeof(zend_reference));
    4585. 

  4585. 			} else if (Z_OPT_REFCOUNTED_P(arg)) {
    4586. 

  4586. 				Z_ADDREF_P(arg);
    4587. 

  4587. 			}
    4588. 

  4588. 		} else {
    4589. 

  4589. 			ZVAL_COPY_VALUE(arg, varptr);
    4590. 

  4590. 		}
    4591. 

  4591. 	}
    4592. 

  4592. 

  4593. 	ZEND_VM_NEXT_OPCODE();
    4594. 

  4594. }
    4595. 

  4595. 

  4596. ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR, NUM)
    4597. 

  4597. {
    4598. 

  4598. 	USE_OPLINE
    4599. 

  4599. 	zval *varptr, *arg;
    4600. 

  4600. 

  4601. 	varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4602. 

  4602. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4603. 

  4603. 	ZVAL_COPY_VALUE(arg, varptr);
    4604. 

  4604. 

  4605. 	if (EXPECTED(Z_ISREF_P(varptr))) {
    4606. 

  4606. 		ZEND_VM_NEXT_OPCODE();
    4607. 

  4607. 	}
    4608. 

  4608. 

  4609. 	SAVE_OPLINE();
    4610. 

  4610. 	ZVAL_NEW_REF(arg, arg);
    4611. 

  4611. 	zend_error(E_NOTICE, "Only variables should be passed by reference");
    4612. 

  4612. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    4613. 

  4613. }
    4614. 

  4614. 

  4615. ZEND_VM_HOT_SEND_HANDLER(50, ZEND_SEND_VAR_NO_REF_EX, VAR, NUM, SPEC(QUICK_ARG))
    4616. 

  4616. {
    4617. 

  4617. 	USE_OPLINE
    4618. 

  4618. 	zval *varptr, *arg;
    4619. 

  4619. 	uint32_t arg_num = opline->op2.num;
    4620. 

  4620. 

  4621. 	if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
    4622. 

  4622. 		if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4623. 

  4623. 			ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR);
    4624. 

  4624. 		}
    4625. 

  4625. 

  4626. 		varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4627. 

  4627. 		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4628. 

  4628. 		ZVAL_COPY_VALUE(arg, varptr);
    4629. 

  4629. 

  4630. 		if (EXPECTED(Z_ISREF_P(varptr) ||
    4631. 

  4631. 		    QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
    4632. 

  4632. 			ZEND_VM_NEXT_OPCODE();
    4633. 

  4633. 		}
    4634. 

  4634. 	} else {
    4635. 

  4635. 		if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4636. 

  4636. 			ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_VAR);
    4637. 

  4637. 		}
    4638. 

  4638. 

  4639. 		varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4640. 

  4640. 		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4641. 

  4641. 		ZVAL_COPY_VALUE(arg, varptr);
    4642. 

  4642. 

  4643. 		if (EXPECTED(Z_ISREF_P(varptr) ||
    4644. 

  4644. 		    ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
    4645. 

  4645. 			ZEND_VM_NEXT_OPCODE();
    4646. 

  4646. 		}
    4647. 

  4647. 	}
    4648. 

  4648. 

  4649. 	SAVE_OPLINE();
    4650. 

  4650. 	ZVAL_NEW_REF(arg, arg);
    4651. 

  4651. 	zend_error(E_NOTICE, "Only variables should be passed by reference");
    4652. 

  4652. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    4653. 

  4653. }
    4654. 

  4654. 

  4655. ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, NUM)
    4656. 

  4656. {
    4657. 

  4657. 	USE_OPLINE
    4658. 

  4658. 	zval *varptr, *arg;
    4659. 

  4659. 

  4660. 	SAVE_OPLINE();
    4661. 

  4661. 	varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
    4662. 

  4662. 

  4663. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4664. 

  4664. 	if (Z_ISREF_P(varptr)) {
    4665. 

  4665. 		Z_ADDREF_P(varptr);
    4666. 

  4666. 	} else {
    4667. 

  4667. 		ZVAL_MAKE_REF_EX(varptr, 2);
    4668. 

  4668. 	}
    4669. 

  4669. 	ZVAL_REF(arg, Z_REF_P(varptr));
    4670. 

  4670. 

  4671. 	FREE_OP1_VAR_PTR();
    4672. 

  4672. 	ZEND_VM_NEXT_OPCODE();
    4673. 

  4673. }
    4674. 

  4674. 

  4675. ZEND_VM_HOT_SEND_HANDLER(66, ZEND_SEND_VAR_EX, VAR|CV, NUM, SPEC(QUICK_ARG))
    4676. 

  4676. {
    4677. 

  4677. 	USE_OPLINE
    4678. 

  4678. 	zval *varptr, *arg;
    4679. 

  4679. 	uint32_t arg_num = opline->op2.num;
    4680. 

  4680. 

  4681. 	if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
    4682. 

  4682. 		if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4683. 

  4683. 			ZEND_VM_C_GOTO(send_var_by_ref);
    4684. 

  4684. 		}
    4685. 

  4685. 	} else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4686. 

  4686. ZEND_VM_C_LABEL(send_var_by_ref):
    4687. 

  4687. 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF);
    4688. 

  4688. 	}
    4689. 

  4689. 

  4690. 	varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    4691. 

  4691. 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
    4692. 

  4692. 		SAVE_OPLINE();
    4693. 

  4693. 		ZVAL_UNDEFINED_OP1();
    4694. 

  4694. 		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4695. 

  4695. 		ZVAL_NULL(arg);
    4696. 

  4696. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    4697. 

  4697. 	}
    4698. 

  4698. 

  4699. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4700. 

  4700. 

  4701. 	if (OP1_TYPE == IS_CV) {
    4702. 

  4702. 		ZVAL_COPY_DEREF(arg, varptr);
    4703. 

  4703. 	} else /* if (OP1_TYPE == IS_VAR) */ {
    4704. 

  4704. 		if (UNEXPECTED(Z_ISREF_P(varptr))) {
    4705. 

  4705. 			zend_refcounted *ref = Z_COUNTED_P(varptr);
    4706. 

  4706. 

  4707. 			varptr = Z_REFVAL_P(varptr);
    4708. 

  4708. 			ZVAL_COPY_VALUE(arg, varptr);
    4709. 

  4709. 			if (UNEXPECTED(GC_DELREF(ref) == 0)) {
    4710. 

  4710. 				efree_size(ref, sizeof(zend_reference));
    4711. 

  4711. 			} else if (Z_OPT_REFCOUNTED_P(arg)) {
    4712. 

  4712. 				Z_ADDREF_P(arg);
    4713. 

  4713. 			}
    4714. 

  4714. 		} else {
    4715. 

  4715. 			ZVAL_COPY_VALUE(arg, varptr);
    4716. 

  4716. 		}
    4717. 

  4717. 	}
    4718. 

  4718. 

  4719. 	ZEND_VM_NEXT_OPCODE();
    4720. 

  4720. }
    4721. 

  4721. 

  4722. ZEND_VM_HOT_SEND_HANDLER(100, ZEND_CHECK_FUNC_ARG, UNUSED, NUM, SPEC(QUICK_ARG))
    4723. 

  4723. {
    4724. 

  4724. 	USE_OPLINE
    4725. 

  4725. 	uint32_t arg_num = opline->op2.num;
    4726. 

  4726. 

  4727. 	if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
    4728. 

  4728. 		if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4729. 

  4729. 			ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
    4730. 

  4730. 		} else {
    4731. 

  4731. 			ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
    4732. 

  4732. 		}
    4733. 

  4733. 	} else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4734. 

  4734. 		ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
    4735. 

  4735. 	} else {
    4736. 

  4736. 		ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
    4737. 

  4737. 	}
    4738. 

  4738. 	ZEND_VM_NEXT_OPCODE();
    4739. 

  4739. }
    4740. 

  4740. 

  4741. ZEND_VM_HOT_HANDLER(185, ZEND_SEND_FUNC_ARG, VAR, NUM)
    4742. 

  4742. {
    4743. 

  4743. 	USE_OPLINE
    4744. 

  4744. 	zval *varptr, *arg;
    4745. 

  4745. 

  4746. 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
    4747. 

  4747. 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF);
    4748. 

  4748. 	}
    4749. 

  4749. 

  4750. 	varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    4751. 

  4751. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    4752. 

  4752. 

  4753. 	if (UNEXPECTED(Z_ISREF_P(varptr))) {
    4754. 

  4754. 		zend_refcounted *ref = Z_COUNTED_P(varptr);
    4755. 

  4755. 

  4756. 		varptr = Z_REFVAL_P(varptr);
    4757. 

  4757. 		ZVAL_COPY_VALUE(arg, varptr);
    4758. 

  4758. 		if (UNEXPECTED(GC_DELREF(ref) == 0)) {
    4759. 

  4759. 			efree_size(ref, sizeof(zend_reference));
    4760. 

  4760. 		} else if (Z_OPT_REFCOUNTED_P(arg)) {
    4761. 

  4761. 			Z_ADDREF_P(arg);
    4762. 

  4762. 		}
    4763. 

  4763. 	} else {
    4764. 

  4764. 		ZVAL_COPY_VALUE(arg, varptr);
    4765. 

  4765. 	}
    4766. 

  4766. 

  4767. 	ZEND_VM_NEXT_OPCODE();
    4768. 

  4768. }
    4769. 

  4769. 

  4770. ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
    4771. 

  4771. {
    4772. 

  4772. 	USE_OPLINE
    4773. 

  4773. 	zval *args;
    4774. 

  4774. 	int arg_num;
    4775. 

  4775. 

  4776. 	SAVE_OPLINE();
    4777. 

  4777. 	args = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    4778. 

  4778. 	arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1;
    4779. 

  4779. 

  4780. ZEND_VM_C_LABEL(send_again):
    4781. 

  4781. 	if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
    4782. 

  4782. 		HashTable *ht = Z_ARRVAL_P(args);
    4783. 

  4783. 		zval *arg, *top;
    4784. 

  4784. 		zend_string *name;
    4785. 

  4785. 

  4786. 		zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht));
    4787. 

  4787. 

  4788. 		if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) {
    4789. 

  4789. 			uint32_t i;
    4790. 

  4790. 			int separate = 0;
    4791. 

  4791. 

  4792. 			/* check if any of arguments are going to be passed by reference */
    4793. 

  4793. 			for (i = 0; i < zend_hash_num_elements(ht); i++) {
    4794. 

  4794. 				if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num + i)) {
    4795. 

  4795. 					separate = 1;
    4796. 

  4796. 					break;
    4797. 

  4797. 				}
    4798. 

  4798. 			}
    4799. 

  4799. 			if (separate) {
    4800. 

  4800. 				SEPARATE_ARRAY(args);
    4801. 

  4801. 				ht = Z_ARRVAL_P(args);
    4802. 

  4802. 			}
    4803. 

  4803. 		}
    4804. 

  4804. 

  4805. 		ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
    4806. 

  4806. 			if (name) {
    4807. 

  4807. 				zend_throw_error(NULL, "Cannot unpack array with string keys");
    4808. 

  4808. 				FREE_OP1();
    4809. 

  4809. 				HANDLE_EXCEPTION();
    4810. 

  4810. 			}
    4811. 

  4811. 

  4812. 			top = ZEND_CALL_ARG(EX(call), arg_num);
    4813. 

  4813. 			if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4814. 

  4814. 				if (Z_ISREF_P(arg)) {
    4815. 

  4815. 					Z_ADDREF_P(arg);
    4816. 

  4816. 					ZVAL_REF(top, Z_REF_P(arg));
    4817. 

  4817. 				} else if (OP1_TYPE & (IS_VAR|IS_CV)) {
    4818. 

  4818. 					/* array is already separated above */
    4819. 

  4819. 					ZVAL_MAKE_REF_EX(arg, 2);
    4820. 

  4820. 					ZVAL_REF(top, Z_REF_P(arg));
    4821. 

  4821. 				} else {
    4822. 

  4822. 					Z_TRY_ADDREF_P(arg);
    4823. 

  4823. 					ZVAL_NEW_REF(top, arg);
    4824. 

  4824. 				}
    4825. 

  4825. 			} else {
    4826. 

  4826. 				ZVAL_COPY_DEREF(top, arg);
    4827. 

  4827. 			}
    4828. 

  4828. 

  4829. 			ZEND_CALL_NUM_ARGS(EX(call))++;
    4830. 

  4830. 			arg_num++;
    4831. 

  4831. 		} ZEND_HASH_FOREACH_END();
    4832. 

  4832. 

  4833. 	} else if (EXPECTED(Z_TYPE_P(args) == IS_OBJECT)) {
    4834. 

  4834. 		zend_class_entry *ce = Z_OBJCE_P(args);
    4835. 

  4835. 		zend_object_iterator *iter;
    4836. 

  4836. 

  4837. 		if (!ce || !ce->get_iterator) {
    4838. 

  4838. 			zend_type_error("Only arrays and Traversables can be unpacked");
    4839. 

  4839. 		} else {
    4840. 

  4840. 

  4841. 			iter = ce->get_iterator(ce, args, 0);
    4842. 

  4842. 			if (UNEXPECTED(!iter)) {
    4843. 

  4843. 				FREE_OP1();
    4844. 

  4844. 				if (!EG(exception)) {
    4845. 

  4845. 					zend_throw_exception_ex(
    4846. 

  4846. 						NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
    4847. 

  4847. 					);
    4848. 

  4848. 				}
    4849. 

  4849. 				HANDLE_EXCEPTION();
    4850. 

  4850. 			}
    4851. 

  4851. 

  4852. 			if (iter->funcs->rewind) {
    4853. 

  4853. 				iter->funcs->rewind(iter);
    4854. 

  4854. 			}
    4855. 

  4855. 

  4856. 			for (; iter->funcs->valid(iter) == SUCCESS; ++arg_num) {
    4857. 

  4857. 				zval *arg, *top;
    4858. 

  4858. 

  4859. 				if (UNEXPECTED(EG(exception) != NULL)) {
    4860. 

  4860. 					break;
    4861. 

  4861. 				}
    4862. 

  4862. 

  4863. 				arg = iter->funcs->get_current_data(iter);
    4864. 

  4864. 				if (UNEXPECTED(EG(exception) != NULL)) {
    4865. 

  4865. 					break;
    4866. 

  4866. 				}
    4867. 

  4867. 

  4868. 				if (iter->funcs->get_current_key) {
    4869. 

  4869. 					zval key;
    4870. 

  4870. 					iter->funcs->get_current_key(iter, &key);
    4871. 

  4871. 					if (UNEXPECTED(EG(exception) != NULL)) {
    4872. 

  4872. 						break;
    4873. 

  4873. 					}
    4874. 

  4874. 

  4875. 					if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) {
    4876. 

  4876. 						zend_throw_error(NULL,
    4877. 

  4877. 							(Z_TYPE(key) == IS_STRING) ?
    4878. 

  4878. 								"Cannot unpack Traversable with string keys" :
    4879. 

  4879. 								"Cannot unpack Traversable with non-integer keys");
    4880. 

  4880. 						zval_ptr_dtor(&key);
    4881. 

  4881. 						break;
    4882. 

  4882. 					}
    4883. 

  4883. 				}
    4884. 

  4884. 

  4885. 				if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4886. 

  4886. 					zend_error(
    4887. 

  4887. 						E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
    4888. 

  4888. 						" by unpacking a Traversable, passing by-value instead", arg_num,
    4889. 

  4889. 						EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
    4890. 

  4890. 						EX(call)->func->common.scope ? "::" : "",
    4891. 

  4891. 						ZSTR_VAL(EX(call)->func->common.function_name)
    4892. 

  4892. 					);
    4893. 

  4893. 				}
    4894. 

  4894. 

  4895. 				ZVAL_DEREF(arg);
    4896. 

  4896. 				Z_TRY_ADDREF_P(arg);
    4897. 

  4897. 

  4898. 				zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1);
    4899. 

  4899. 				top = ZEND_CALL_ARG(EX(call), arg_num);
    4900. 

  4900. 				ZVAL_COPY_VALUE(top, arg);
    4901. 

  4901. 				ZEND_CALL_NUM_ARGS(EX(call))++;
    4902. 

  4902. 

  4903. 				iter->funcs->move_forward(iter);
    4904. 

  4904. 			}
    4905. 

  4905. 

  4906. 			zend_iterator_dtor(iter);
    4907. 

  4907. 		}
    4908. 

  4908. 	} else if (EXPECTED(Z_ISREF_P(args))) {
    4909. 

  4909. 		args = Z_REFVAL_P(args);
    4910. 

  4910. 		ZEND_VM_C_GOTO(send_again);
    4911. 

  4911. 	} else {
    4912. 

  4912. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(args) == IS_UNDEF)) {
    4913. 

  4913. 			ZVAL_UNDEFINED_OP1();
    4914. 

  4914. 		}
    4915. 

  4915. 		zend_type_error("Only arrays and Traversables can be unpacked");
    4916. 

  4916. 	}
    4917. 

  4917. 

  4918. 	FREE_OP1();
    4919. 

  4919. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    4920. 

  4920. }
    4921. 

  4921. 

  4922. ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY, NUM)
    4923. 

  4923. {
    4924. 

  4924. 	USE_OPLINE
    4925. 

  4925. 	zval *args;
    4926. 

  4926. 

  4927. 	SAVE_OPLINE();
    4928. 

  4928. 	args = GET_OP1_ZVAL_PTR(BP_VAR_R);
    4929. 

  4929. 

  4930. 	if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) {
    4931. 

  4931. 		if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) {
    4932. 

  4932. 			args = Z_REFVAL_P(args);
    4933. 

  4933. 			if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
    4934. 

  4934. 				ZEND_VM_C_GOTO(send_array);
    4935. 

  4935. 			}
    4936. 

  4936. 		}
    4937. 

  4937. 		zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
    4938. 

  4938. 		FREE_UNFETCHED_OP2();
    4939. 

  4939. 		FREE_OP1();
    4940. 

  4940. 		HANDLE_EXCEPTION();
    4941. 

  4941. 	} else {
    4942. 

  4942. 		uint32_t arg_num;
    4943. 

  4943. 		HashTable *ht;
    4944. 

  4944. 		zval *arg, *param;
    4945. 

  4945. 

  4946. 

  4947. ZEND_VM_C_LABEL(send_array):
    4948. 

  4948. 		ht = Z_ARRVAL_P(args);
    4949. 

  4949. 		if (OP2_TYPE != IS_UNUSED) {
    4950. 

  4950. 			zval *op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
    4951. 

  4951. 			uint32_t skip = opline->extended_value;
    4952. 

  4952. 			uint32_t count = zend_hash_num_elements(ht);
    4953. 

  4953. 			zend_long len = zval_get_long(op2);
    4954. 

  4954. 

  4955. 			if (len < 0) {
    4956. 

  4956. 				len += (zend_long)(count - skip);
    4957. 

  4957. 			}
    4958. 

  4958. 			if (skip < count && len > 0) {
    4959. 

  4959. 				if (len > (zend_long)(count - skip)) {
    4960. 

  4960. 					len = (zend_long)(count - skip);
    4961. 

  4961. 				}
    4962. 

  4962. 				zend_vm_stack_extend_call_frame(&EX(call), 0, len);
    4963. 

  4963. 				arg_num = 1;
    4964. 

  4964. 				param = ZEND_CALL_ARG(EX(call), 1);
    4965. 

  4965. 				ZEND_HASH_FOREACH_VAL(ht, arg) {
    4966. 

  4966. 					if (skip > 0) {
    4967. 

  4967. 						skip--;
    4968. 

  4968. 						continue;
    4969. 

  4969. 					} else if ((zend_long)(arg_num - 1) >= len) {
    4970. 

  4970. 						break;
    4971. 

  4971. 					} else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4972. 

  4972. 						if (UNEXPECTED(!Z_ISREF_P(arg))) {
    4973. 

  4973. 							if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4974. 

  4974. 								/* By-value send is not allowed -- emit a warning,
    4975. 

  4975. 								 * but still perform the call. */
    4976. 

  4976. 								zend_param_must_be_ref(EX(call)->func, arg_num);
    4977. 

  4977. 							}
    4978. 

  4978. 						}
    4979. 

  4979. 					} else {
    4980. 

  4980. 						if (Z_ISREF_P(arg) &&
    4981. 

  4981. 						    !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
    4982. 

  4982. 							/* don't separate references for __call */
    4983. 

  4983. 							arg = Z_REFVAL_P(arg);
    4984. 

  4984. 						}
    4985. 

  4985. 					}
    4986. 

  4986. 					ZVAL_COPY(param, arg);
    4987. 

  4987. 					ZEND_CALL_NUM_ARGS(EX(call))++;
    4988. 

  4988. 					arg_num++;
    4989. 

  4989. 					param++;
    4990. 

  4990. 				} ZEND_HASH_FOREACH_END();
    4991. 

  4991. 			}
    4992. 

  4992. 			FREE_OP2();
    4993. 

  4993. 		} else {
    4994. 

  4994. 			zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
    4995. 

  4995. 			arg_num = 1;
    4996. 

  4996. 			param = ZEND_CALL_ARG(EX(call), 1);
    4997. 

  4997. 			ZEND_HASH_FOREACH_VAL(ht, arg) {
    4998. 

  4998. 				if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    4999. 

  4999. 					if (UNEXPECTED(!Z_ISREF_P(arg))) {
    5000. 

  5000. 						if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    5001. 

  5001. 							/* By-value send is not allowed -- emit a warning,
    5002. 

  5002. 							 * but still perform the call. */
    5003. 

  5003. 							zend_param_must_be_ref(EX(call)->func, arg_num);
    5004. 

  5004. 						}
    5005. 

  5005. 					}
    5006. 

  5006. 				} else {
    5007. 

  5007. 					if (Z_ISREF_P(arg) &&
    5008. 

  5008. 					    !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
    5009. 

  5009. 						/* don't separate references for __call */
    5010. 

  5010. 						arg = Z_REFVAL_P(arg);
    5011. 

  5011. 					}
    5012. 

  5012. 				}
    5013. 

  5013. 				ZVAL_COPY(param, arg);
    5014. 

  5014. 				ZEND_CALL_NUM_ARGS(EX(call))++;
    5015. 

  5015. 				arg_num++;
    5016. 

  5016. 				param++;
    5017. 

  5017. 			} ZEND_HASH_FOREACH_END();
    5018. 

  5018. 		}
    5019. 

  5019. 	}
    5020. 

  5020. 	FREE_OP1();
    5021. 

  5021. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5022. 

  5022. }
    5023. 

  5023. 

  5024. ZEND_VM_HANDLER(120, ZEND_SEND_USER, CONST|TMP|VAR|CV, NUM)
    5025. 

  5025. {
    5026. 

  5026. 	USE_OPLINE
    5027. 

  5027. 	zval *arg, *param;
    5028. 

  5028. 

  5029. 	SAVE_OPLINE();
    5030. 

  5030. 

  5031. 	if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
    5032. 

  5032. 		zend_param_must_be_ref(EX(call)->func, opline->op2.num);
    5033. 

  5033. 	}
    5034. 

  5034. 

  5035. 	arg = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
    5036. 

  5036. 	param = ZEND_CALL_VAR(EX(call), opline->result.var);
    5037. 

  5037. 	ZVAL_COPY(param, arg);
    5038. 

  5038. 	FREE_OP1();
    5039. 

  5039. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5040. 

  5040. }
    5041. 

  5041. 

  5042. ZEND_VM_COLD_HELPER(zend_missing_arg_helper, ANY, ANY)
    5043. 

  5043. {
    5044. 

  5044. #ifdef ZEND_VM_IP_GLOBAL_REG
    5045. 

  5045. 	USE_OPLINE
    5046. 

  5046. 

  5047. 	SAVE_OPLINE();
    5048. 

  5048. #endif
    5049. 

  5049. 	zend_missing_arg_error(execute_data);
    5050. 

  5050. 	HANDLE_EXCEPTION();
    5051. 

  5051. }
    5052. 

  5052. 

  5053. ZEND_VM_COLD_HELPER(zend_verify_recv_arg_type_helper, ANY, ANY, zval *op_1)
    5054. 

  5054. {
    5055. 

  5055. 	USE_OPLINE
    5056. 

  5056. 

  5057. 	SAVE_OPLINE();
    5058. 

  5058. 	if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), opline->op1.num, op_1, CACHE_ADDR(opline->extended_value)))) {
    5059. 

  5059. 		HANDLE_EXCEPTION();
    5060. 

  5060. 	}
    5061. 

  5061. 

  5062. 	ZEND_VM_NEXT_OPCODE();
    5063. 

  5063. }
    5064. 

  5064. 

  5065. ZEND_VM_HOT_HANDLER(63, ZEND_RECV, NUM, UNUSED, CACHE_SLOT)
    5066. 

  5066. {
    5067. 

  5067. 	USE_OPLINE
    5068. 

  5068. 	uint32_t arg_num = opline->op1.num;
    5069. 

  5069. 	zval *param;
    5070. 

  5070. 

  5071. 	if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
    5072. 

  5072. 		ZEND_VM_DISPATCH_TO_HELPER(zend_missing_arg_helper);
    5073. 

  5073. 	}
    5074. 

  5074. 

  5075. 	param = EX_VAR(opline->result.var);
    5076. 

  5076. 

  5077. 	if (UNEXPECTED(!(opline->op2.num & (1u << Z_TYPE_P(param))))) {
    5078. 

  5078. 		ZEND_VM_DISPATCH_TO_HELPER(zend_verify_recv_arg_type_helper, op_1, param);
    5079. 

  5079. 	}
    5080. 

  5080. 

  5081. 	ZEND_VM_NEXT_OPCODE();
    5082. 

  5082. }
    5083. 

  5083. 

  5084. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_RECV, op->op2.num == MAY_BE_ANY, ZEND_RECV_NOTYPE, NUM, NUM, CACHE_SLOT)
    5085. 

  5085. {
    5086. 

  5086. 	USE_OPLINE
    5087. 

  5087. 	uint32_t arg_num = opline->op1.num;
    5088. 

  5088. 

  5089. 	if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
    5090. 

  5090. 		ZEND_VM_DISPATCH_TO_HELPER(zend_missing_arg_helper);
    5091. 

  5091. 	}
    5092. 

  5092. 

  5093. 	ZEND_VM_NEXT_OPCODE();
    5094. 

  5094. }
    5095. 

  5095. 

  5096. ZEND_VM_HOT_HANDLER(64, ZEND_RECV_INIT, NUM, CONST, CACHE_SLOT)
    5097. 

  5097. {
    5098. 

  5098. 	USE_OPLINE
    5099. 

  5099. 	uint32_t arg_num;
    5100. 

  5100. 	zval *param;
    5101. 

  5101. 

  5102. 	ZEND_VM_REPEATABLE_OPCODE
    5103. 

  5103. 

  5104. 	arg_num = opline->op1.num;
    5105. 

  5105. 	param = EX_VAR(opline->result.var);
    5106. 

  5106. 	if (arg_num > EX_NUM_ARGS()) {
    5107. 

  5107. 		zval *default_value = RT_CONSTANT(opline, opline->op2);
    5108. 

  5108. 

  5109. 		if (Z_OPT_TYPE_P(default_value) == IS_CONSTANT_AST) {
    5110. 

  5110. 			zval *cache_val = (zval*)CACHE_ADDR(Z_CACHE_SLOT_P(default_value));
    5111. 

  5111. 

  5112. 			/* we keep in cache only not refcounted values */
    5113. 

  5113. 			if (Z_TYPE_P(cache_val) != IS_UNDEF) {
    5114. 

  5114. 				ZVAL_COPY_VALUE(param, cache_val);
    5115. 

  5115. 			} else {
    5116. 

  5116. 				SAVE_OPLINE();
    5117. 

  5117. 				ZVAL_COPY(param, default_value);
    5118. 

  5118. 				if (UNEXPECTED(zval_update_constant_ex(param, EX(func)->op_array.scope) != SUCCESS)) {
    5119. 

  5119. 					zval_ptr_dtor_nogc(param);
    5120. 

  5120. 					ZVAL_UNDEF(param);
    5121. 

  5121. 					HANDLE_EXCEPTION();
    5122. 

  5122. 				}
    5123. 

  5123. 				if (!Z_REFCOUNTED_P(param)) {
    5124. 

  5124. 					ZVAL_COPY_VALUE(cache_val, param);
    5125. 

  5125. 				}
    5126. 

  5126. 			}
    5127. 

  5127. 			ZEND_VM_C_GOTO(recv_init_check_type);
    5128. 

  5128. 		} else {
    5129. 

  5129. 			ZVAL_COPY(param, default_value);
    5130. 

  5130. 		}
    5131. 

  5131. 	} else {
    5132. 

  5132. ZEND_VM_C_LABEL(recv_init_check_type):
    5133. 

  5133. 		if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
    5134. 

  5134. 			SAVE_OPLINE();
    5135. 

  5135. 			if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), arg_num, param, CACHE_ADDR(opline->extended_value)))) {
    5136. 

  5136. 				HANDLE_EXCEPTION();
    5137. 

  5137. 			}
    5138. 

  5138. 		}
    5139. 

  5139. 	}
    5140. 

  5140. 

  5141. 	ZEND_VM_REPEAT_OPCODE(ZEND_RECV_INIT);
    5142. 

  5142. 	ZEND_VM_NEXT_OPCODE();
    5143. 

  5143. }
    5144. 

  5144. 

  5145. ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, NUM, UNUSED, CACHE_SLOT)
    5146. 

  5146. {
    5147. 

  5147. 	USE_OPLINE
    5148. 

  5148. 	uint32_t arg_num = opline->op1.num;
    5149. 

  5149. 	uint32_t arg_count = EX_NUM_ARGS();
    5150. 

  5150. 	zval *params;
    5151. 

  5151. 

  5152. 	SAVE_OPLINE();
    5153. 

  5153. 

  5154. 	params = EX_VAR(opline->result.var);
    5155. 

  5155. 

  5156. 	if (arg_num <= arg_count) {
    5157. 

  5157. 		zval *param;
    5158. 

  5158. 

  5159. 		array_init_size(params, arg_count - arg_num + 1);
    5160. 

  5160. 		zend_hash_real_init_packed(Z_ARRVAL_P(params));
    5161. 

  5161. 		ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
    5162. 

  5162. 			param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
    5163. 

  5163. 			if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
    5164. 

  5164. 				do {
    5165. 

  5165. 					if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_num, param, CACHE_ADDR(opline->extended_value)))) {
    5166. 

  5166. 						ZEND_HASH_FILL_FINISH();
    5167. 

  5167. 						HANDLE_EXCEPTION();
    5168. 

  5168. 					}
    5169. 

  5169. 

  5170. 					if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
    5171. 

  5171. 					ZEND_HASH_FILL_ADD(param);
    5172. 

  5172. 					param++;
    5173. 

  5173. 				} while (++arg_num <= arg_count);
    5174. 

  5174. 			} else {
    5175. 

  5175. 				do {
    5176. 

  5176. 					if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
    5177. 

  5177. 					ZEND_HASH_FILL_ADD(param);
    5178. 

  5178. 					param++;
    5179. 

  5179. 				} while (++arg_num <= arg_count);
    5180. 

  5180. 			}
    5181. 

  5181. 		} ZEND_HASH_FILL_END();
    5182. 

  5182. 	} else {
    5183. 

  5183. 		ZVAL_EMPTY_ARRAY(params);
    5184. 

  5184. 	}
    5185. 

  5185. 

  5186. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5187. 

  5187. }
    5188. 

  5188. 

  5189. ZEND_VM_COLD_CONST_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY)
    5190. 

  5190. {
    5191. 

  5191. 	USE_OPLINE
    5192. 

  5192. 	zval *val;
    5193. 

  5193. 

  5194. 	val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    5195. 

  5195. 	if (Z_TYPE_INFO_P(val) == IS_TRUE) {
    5196. 

  5196. 		ZVAL_TRUE(EX_VAR(opline->result.var));
    5197. 

  5197. 	} else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
    5198. 

  5198. 		/* The result and op1 can be the same cv zval */
    5199. 

  5199. 		const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
    5200. 

  5200. 		ZVAL_FALSE(EX_VAR(opline->result.var));
    5201. 

  5201. 		if (OP1_TYPE == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
    5202. 

  5202. 			SAVE_OPLINE();
    5203. 

  5203. 			ZVAL_UNDEFINED_OP1();
    5204. 

  5204. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5205. 

  5205. 		}
    5206. 

  5206. 	} else {
    5207. 

  5207. 		SAVE_OPLINE();
    5208. 

  5208. 		ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
    5209. 

  5209. 		FREE_OP1();
    5210. 

  5210. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5211. 

  5211. 	}
    5212. 

  5212. 	ZEND_VM_NEXT_OPCODE();
    5213. 

  5213. }
    5214. 

  5214. 

  5215. ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2)
    5216. 

  5216. {
    5217. 

  5217. 	int ret;
    5218. 

  5218. 	USE_OPLINE
    5219. 

  5219. 

  5220. 	SAVE_OPLINE();
    5221. 

  5221. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
    5222. 

  5222. 		op_1 = ZVAL_UNDEFINED_OP1();
    5223. 

  5223. 	}
    5224. 

  5224. 	if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
    5225. 

  5225. 		op_2 = ZVAL_UNDEFINED_OP2();
    5226. 

  5226. 	}
    5227. 

  5227. 	ret = zend_compare(op_1, op_2);
    5228. 

  5228. 	if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
    5229. 

  5229. 		zval_ptr_dtor_nogc(op_2);
    5230. 

  5230. 	}
    5231. 

  5231. 	ZEND_VM_SMART_BRANCH(ret == 0, 1);
    5232. 

  5232. }
    5233. 

  5233. 

  5234. ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
    5235. 

  5235. {
    5236. 

  5236. 	USE_OPLINE
    5237. 

  5237. 	zval *op1, *op2;
    5238. 

  5238. 	double d1, d2;
    5239. 

  5239. 

  5240. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    5241. 

  5241. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    5242. 

  5242. 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
    5243. 

  5243. 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    5244. 

  5244. 			if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
    5245. 

  5245. ZEND_VM_C_LABEL(case_true):
    5246. 

  5246. 				ZEND_VM_SMART_BRANCH_TRUE();
    5247. 

  5247. 			} else {
    5248. 

  5248. ZEND_VM_C_LABEL(case_false):
    5249. 

  5249. 				ZEND_VM_SMART_BRANCH_FALSE();
    5250. 

  5250. 			}
    5251. 

  5251. 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
    5252. 

  5252. 			d1 = (double)Z_LVAL_P(op1);
    5253. 

  5253. 			d2 = Z_DVAL_P(op2);
    5254. 

  5254. 			ZEND_VM_C_GOTO(case_double);
    5255. 

  5255. 		}
    5256. 

  5256. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
    5257. 

  5257. 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
    5258. 

  5258. 			d1 = Z_DVAL_P(op1);
    5259. 

  5259. 			d2 = Z_DVAL_P(op2);
    5260. 

  5260. ZEND_VM_C_LABEL(case_double):
    5261. 

  5261. 			if (d1 == d2) {
    5262. 

  5262. 				ZEND_VM_C_GOTO(case_true);
    5263. 

  5263. 			} else {
    5264. 

  5264. 				ZEND_VM_C_GOTO(case_false);
    5265. 

  5265. 			}
    5266. 

  5266. 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
    5267. 

  5267. 			d1 = Z_DVAL_P(op1);
    5268. 

  5268. 			d2 = (double)Z_LVAL_P(op2);
    5269. 

  5269. 			ZEND_VM_C_GOTO(case_double);
    5270. 

  5270. 		}
    5271. 

  5271. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
    5272. 

  5272. 		if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
    5273. 

  5273. 			int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
    5274. 

  5274. 			FREE_OP2();
    5275. 

  5275. 			if (result) {
    5276. 

  5276. 				ZEND_VM_C_GOTO(case_true);
    5277. 

  5277. 			} else {
    5278. 

  5278. 				ZEND_VM_C_GOTO(case_false);
    5279. 

  5279. 			}
    5280. 

  5280. 		}
    5281. 

  5281. 	}
    5282. 

  5282. 	ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper, op_1, op1, op_2, op2);
    5283. 

  5283. }
    5284. 

  5284. 

  5285. ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM)
    5286. 

  5286. {
    5287. 

  5287. 	USE_OPLINE
    5288. 

  5288. 	zval *result;
    5289. 

  5289. 	zend_function *constructor;
    5290. 

  5290. 	zend_class_entry *ce;
    5291. 

  5291. 	zend_execute_data *call;
    5292. 

  5292. 

  5293. 	SAVE_OPLINE();
    5294. 

  5294. 	if (OP1_TYPE == IS_CONST) {
    5295. 

  5295. 		ce = CACHED_PTR(opline->op2.num);
    5296. 

  5296. 		if (UNEXPECTED(ce == NULL)) {
    5297. 

  5297. 			ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
    5298. 

  5298. 			if (UNEXPECTED(ce == NULL)) {
    5299. 

  5299. 				ZEND_ASSERT(EG(exception));
    5300. 

  5300. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    5301. 

  5301. 				HANDLE_EXCEPTION();
    5302. 

  5302. 			}
    5303. 

  5303. 			CACHE_PTR(opline->op2.num, ce);
    5304. 

  5304. 		}
    5305. 

  5305. 	} else if (OP1_TYPE == IS_UNUSED) {
    5306. 

  5306. 		ce = zend_fetch_class(NULL, opline->op1.num);
    5307. 

  5307. 		if (UNEXPECTED(ce == NULL)) {
    5308. 

  5308. 			ZEND_ASSERT(EG(exception));
    5309. 

  5309. 			ZVAL_UNDEF(EX_VAR(opline->result.var));
    5310. 

  5310. 			HANDLE_EXCEPTION();
    5311. 

  5311. 		}
    5312. 

  5312. 	} else {
    5313. 

  5313. 		ce = Z_CE_P(EX_VAR(opline->op1.var));
    5314. 

  5314. 	}
    5315. 

  5315. 

  5316. 	result = EX_VAR(opline->result.var);
    5317. 

  5317. 	if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
    5318. 

  5318. 		ZVAL_UNDEF(result);
    5319. 

  5319. 		HANDLE_EXCEPTION();
    5320. 

  5320. 	}
    5321. 

  5321. 

  5322. 	constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
    5323. 

  5323. 	if (constructor == NULL) {
    5324. 

  5324. 		if (UNEXPECTED(EG(exception))) {
    5325. 

  5325. 			HANDLE_EXCEPTION();
    5326. 

  5326. 		}
    5327. 

  5327. 

  5328. 		/* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
    5329. 

  5329. 		 * opcode is DO_FCALL in case EXT instructions are used. */
    5330. 

  5330. 		if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
    5331. 

  5331. 			ZEND_VM_NEXT_OPCODE_EX(1, 2);
    5332. 

  5332. 		}
    5333. 

  5333. 

  5334. 		/* Perform a dummy function call */
    5335. 

  5335. 		call = zend_vm_stack_push_call_frame(
    5336. 

  5336. 			ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
    5337. 

  5337. 			opline->extended_value, NULL);
    5338. 

  5338. 	} else {
    5339. 

  5339. 		if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
    5340. 

  5340. 			init_func_run_time_cache(&constructor->op_array);
    5341. 

  5341. 		}
    5342. 

  5342. 		/* We are not handling overloaded classes right now */
    5343. 

  5343. 		call = zend_vm_stack_push_call_frame(
    5344. 

  5344. 			ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
    5345. 

  5345. 			constructor,
    5346. 

  5346. 			opline->extended_value,
    5347. 

  5347. 			Z_OBJ_P(result));
    5348. 

  5348. 		Z_ADDREF_P(result);
    5349. 

  5349. 	}
    5350. 

  5350. 

  5351. 	call->prev_execute_data = EX(call);
    5352. 

  5352. 	EX(call) = call;
    5353. 

  5353. 	ZEND_VM_NEXT_OPCODE();
    5354. 

  5354. }
    5355. 

  5355. 

  5356. ZEND_VM_COLD_CONST_HANDLER(110, ZEND_CLONE, CONST|TMPVAR|UNUSED|THIS|CV, ANY)
    5357. 

  5357. {
    5358. 

  5358. 	USE_OPLINE
    5359. 

  5359. 	zval *obj;
    5360. 

  5360. 	zend_object *zobj;
    5361. 

  5361. 	zend_class_entry *ce, *scope;
    5362. 

  5362. 	zend_function *clone;
    5363. 

  5363. 	zend_object_clone_obj_t clone_call;
    5364. 

  5364. 

  5365. 	SAVE_OPLINE();
    5366. 

  5366. 	obj = GET_OP1_OBJ_ZVAL_PTR_UNDEF(BP_VAR_R);
    5367. 

  5367. 

  5368. 	do {
    5369. 

  5369. 		if (OP1_TYPE == IS_CONST ||
    5370. 

  5370. 		    (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
    5371. 

  5371. 		    if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
    5372. 

  5372. 				obj = Z_REFVAL_P(obj);
    5373. 

  5373. 				if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
    5374. 

  5374. 					break;
    5375. 

  5375. 				}
    5376. 

  5376. 			}
    5377. 

  5377. 			ZVAL_UNDEF(EX_VAR(opline->result.var));
    5378. 

  5378. 			if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
    5379. 

  5379. 				ZVAL_UNDEFINED_OP1();
    5380. 

  5380. 				if (UNEXPECTED(EG(exception) != NULL)) {
    5381. 

  5381. 					HANDLE_EXCEPTION();
    5382. 

  5382. 				}
    5383. 

  5383. 			}
    5384. 

  5384. 			zend_throw_error(NULL, "__clone method called on non-object");
    5385. 

  5385. 			FREE_OP1();
    5386. 

  5386. 			HANDLE_EXCEPTION();
    5387. 

  5387. 		}
    5388. 

  5388. 	} while (0);
    5389. 

  5389. 

  5390. 	zobj = Z_OBJ_P(obj);
    5391. 

  5391. 	ce = zobj->ce;
    5392. 

  5392. 	clone = ce->clone;
    5393. 

  5393. 	clone_call = zobj->handlers->clone_obj;
    5394. 

  5394. 	if (UNEXPECTED(clone_call == NULL)) {
    5395. 

  5395. 		zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
    5396. 

  5396. 		FREE_OP1();
    5397. 

  5397. 		ZVAL_UNDEF(EX_VAR(opline->result.var));
    5398. 

  5398. 		HANDLE_EXCEPTION();
    5399. 

  5399. 	}
    5400. 

  5400. 

  5401. 	if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
    5402. 

  5402. 		scope = EX(func)->op_array.scope;
    5403. 

  5403. 		if (clone->common.scope != scope) {
    5404. 

  5404. 			if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
    5405. 

  5405. 			 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
    5406. 

  5406. 				zend_wrong_clone_call(clone, scope);
    5407. 

  5407. 				FREE_OP1();
    5408. 

  5408. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    5409. 

  5409. 				HANDLE_EXCEPTION();
    5410. 

  5410. 			}
    5411. 

  5411. 		}
    5412. 

  5412. 	}
    5413. 

  5413. 

  5414. 	ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
    5415. 

  5415. 

  5416. 	FREE_OP1();
    5417. 

  5417. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5418. 

  5418. }
    5419. 

  5419. 

  5420. ZEND_VM_HOT_HANDLER(99, ZEND_FETCH_CONSTANT, UNUSED|CONST_FETCH, CONST, CACHE_SLOT)
    5421. 

  5421. {
    5422. 

  5422. 	USE_OPLINE
    5423. 

  5423. 	zend_constant *c;
    5424. 

  5424. 

  5425. 	c = CACHED_PTR(opline->extended_value);
    5426. 

  5426. 	if (EXPECTED(c != NULL) && EXPECTED(!IS_SPECIAL_CACHE_VAL(c))) {
    5427. 

  5427. 		ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
    5428. 

  5428. 		ZEND_VM_NEXT_OPCODE();
    5429. 

  5429. 	}
    5430. 

  5430. 

  5431. 	SAVE_OPLINE();
    5432. 

  5432. 	zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC);
    5433. 

  5433. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5434. 

  5434. }
    5435. 

  5435. 

  5436. ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CONST, CACHE_SLOT)
    5437. 

  5437. {
    5438. 

  5438. 	zend_class_entry *ce, *scope;
    5439. 

  5439. 	zend_class_constant *c;
    5440. 

  5440. 	zval *value, *zv;
    5441. 

  5441. 	USE_OPLINE
    5442. 

  5442. 

  5443. 	SAVE_OPLINE();
    5444. 

  5444. 

  5445. 	do {
    5446. 

  5446. 		if (OP1_TYPE == IS_CONST) {
    5447. 

  5447. 			if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
    5448. 

  5448. 				value = CACHED_PTR(opline->extended_value + sizeof(void*));
    5449. 

  5449. 				break;
    5450. 

  5450. 			} else if (EXPECTED(CACHED_PTR(opline->extended_value))) {
    5451. 

  5451. 				ce = CACHED_PTR(opline->extended_value);
    5452. 

  5452. 			} else {
    5453. 

  5453. 				ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
    5454. 

  5454. 				if (UNEXPECTED(ce == NULL)) {
    5455. 

  5455. 					ZEND_ASSERT(EG(exception));
    5456. 

  5456. 					ZVAL_UNDEF(EX_VAR(opline->result.var));
    5457. 

  5457. 					HANDLE_EXCEPTION();
    5458. 

  5458. 				}
    5459. 

  5459. 			}
    5460. 

  5460. 		} else {
    5461. 

  5461. 			if (OP1_TYPE == IS_UNUSED) {
    5462. 

  5462. 				ce = zend_fetch_class(NULL, opline->op1.num);
    5463. 

  5463. 				if (UNEXPECTED(ce == NULL)) {
    5464. 

  5464. 					ZEND_ASSERT(EG(exception));
    5465. 

  5465. 					ZVAL_UNDEF(EX_VAR(opline->result.var));
    5466. 

  5466. 					HANDLE_EXCEPTION();
    5467. 

  5467. 				}
    5468. 

  5468. 			} else {
    5469. 

  5469. 				ce = Z_CE_P(EX_VAR(opline->op1.var));
    5470. 

  5470. 			}
    5471. 

  5471. 			if (EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
    5472. 

  5472. 				value = CACHED_PTR(opline->extended_value + sizeof(void*));
    5473. 

  5473. 				break;
    5474. 

  5474. 			}
    5475. 

  5475. 		}
    5476. 

  5476. 

  5477. 		zv = zend_hash_find_ex(&ce->constants_table, Z_STR_P(RT_CONSTANT(opline, opline->op2)), 1);
    5478. 

  5478. 		if (EXPECTED(zv != NULL)) {
    5479. 

  5479. 			c = Z_PTR_P(zv);
    5480. 

  5480. 			scope = EX(func)->op_array.scope;
    5481. 

  5481. 			if (!zend_verify_const_access(c, scope)) {
    5482. 

  5482. 				zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(ce->name), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
    5483. 

  5483. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    5484. 

  5484. 				HANDLE_EXCEPTION();
    5485. 

  5485. 			}
    5486. 

  5486. 			value = &c->value;
    5487. 

  5487. 			if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
    5488. 

  5488. 				zval_update_constant_ex(value, c->ce);
    5489. 

  5489. 				if (UNEXPECTED(EG(exception) != NULL)) {
    5490. 

  5490. 					ZVAL_UNDEF(EX_VAR(opline->result.var));
    5491. 

  5491. 					HANDLE_EXCEPTION();
    5492. 

  5492. 				}
    5493. 

  5493. 			}
    5494. 

  5494. 			CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
    5495. 

  5495. 		} else {
    5496. 

  5496. 			zend_throw_error(NULL, "Undefined class constant '%s::%s'",
    5497. 

  5497. 				ZSTR_VAL(ce->name), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
    5498. 

  5498. 			ZVAL_UNDEF(EX_VAR(opline->result.var));
    5499. 

  5499. 			HANDLE_EXCEPTION();
    5500. 

  5500. 		}
    5501. 

  5501. 	} while (0);
    5502. 

  5502. 

  5503. 	ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
    5504. 

  5504. 

  5505. 	ZEND_VM_NEXT_OPCODE();
    5506. 

  5506. }
    5507. 

  5507. 

  5508. ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, REF)
    5509. 

  5509. {
    5510. 

  5510. 	USE_OPLINE
    5511. 

  5511. 	zval *expr_ptr, new_expr;
    5512. 

  5512. 

  5513. 	SAVE_OPLINE();
    5514. 

  5514. 	if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) &&
    5515. 

  5515. 	    UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
    5516. 

  5516. 		expr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
    5517. 

  5517. 		if (Z_ISREF_P(expr_ptr)) {
    5518. 

  5518. 			Z_ADDREF_P(expr_ptr);
    5519. 

  5519. 		} else {
    5520. 

  5520. 			ZVAL_MAKE_REF_EX(expr_ptr, 2);
    5521. 

  5521. 		}
    5522. 

  5522. 		FREE_OP1_VAR_PTR();
    5523. 

  5523. 	} else {
    5524. 

  5524. 		expr_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    5525. 

  5525. 		if (OP1_TYPE == IS_TMP_VAR) {
    5526. 

  5526. 			/* pass */
    5527. 

  5527. 		} else if (OP1_TYPE == IS_CONST) {
    5528. 

  5528. 			Z_TRY_ADDREF_P(expr_ptr);
    5529. 

  5529. 		} else if (OP1_TYPE == IS_CV) {
    5530. 

  5530. 			ZVAL_DEREF(expr_ptr);
    5531. 

  5531. 			Z_TRY_ADDREF_P(expr_ptr);
    5532. 

  5532. 		} else /* if (OP1_TYPE == IS_VAR) */ {
    5533. 

  5533. 			if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
    5534. 

  5534. 				zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
    5535. 

  5535. 

  5536. 				expr_ptr = Z_REFVAL_P(expr_ptr);
    5537. 

  5537. 				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
    5538. 

  5538. 					ZVAL_COPY_VALUE(&new_expr, expr_ptr);
    5539. 

  5539. 					expr_ptr = &new_expr;
    5540. 

  5540. 					efree_size(ref, sizeof(zend_reference));
    5541. 

  5541. 				} else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
    5542. 

  5542. 					Z_ADDREF_P(expr_ptr);
    5543. 

  5543. 				}
    5544. 

  5544. 			}
    5545. 

  5545. 		}
    5546. 

  5546. 	}
    5547. 

  5547. 

  5548. 	if (OP2_TYPE != IS_UNUSED) {
    5549. 

  5549. 		zval *offset = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    5550. 

  5550. 		zend_string *str;
    5551. 

  5551. 		zend_ulong hval;
    5552. 

  5552. 

  5553. ZEND_VM_C_LABEL(add_again):
    5554. 

  5554. 		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
    5555. 

  5555. 			str = Z_STR_P(offset);
    5556. 

  5556. 			if (OP2_TYPE != IS_CONST) {
    5557. 

  5557. 				if (ZEND_HANDLE_NUMERIC(str, hval)) {
    5558. 

  5558. 					ZEND_VM_C_GOTO(num_index);
    5559. 

  5559. 				}
    5560. 

  5560. 			}
    5561. 

  5561. ZEND_VM_C_LABEL(str_index):
    5562. 

  5562. 			zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
    5563. 

  5563. 		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
    5564. 

  5564. 			hval = Z_LVAL_P(offset);
    5565. 

  5565. ZEND_VM_C_LABEL(num_index):
    5566. 

  5566. 			zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
    5567. 

  5567. 		} else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
    5568. 

  5568. 			offset = Z_REFVAL_P(offset);
    5569. 

  5569. 			ZEND_VM_C_GOTO(add_again);
    5570. 

  5570. 		} else if (Z_TYPE_P(offset) == IS_NULL) {
    5571. 

  5571. 			str = ZSTR_EMPTY_ALLOC();
    5572. 

  5572. 			ZEND_VM_C_GOTO(str_index);
    5573. 

  5573. 		} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
    5574. 

  5574. 			hval = zend_dval_to_lval(Z_DVAL_P(offset));
    5575. 

  5575. 			ZEND_VM_C_GOTO(num_index);
    5576. 

  5576. 		} else if (Z_TYPE_P(offset) == IS_FALSE) {
    5577. 

  5577. 			hval = 0;
    5578. 

  5578. 			ZEND_VM_C_GOTO(num_index);
    5579. 

  5579. 		} else if (Z_TYPE_P(offset) == IS_TRUE) {
    5580. 

  5580. 			hval = 1;
    5581. 

  5581. 			ZEND_VM_C_GOTO(num_index);
    5582. 

  5582. 		} else if (Z_TYPE_P(offset) == IS_RESOURCE) {
    5583. 

  5583. 			zend_use_resource_as_offset(offset);
    5584. 

  5584. 			hval = Z_RES_HANDLE_P(offset);
    5585. 

  5585. 			ZEND_VM_C_GOTO(num_index);
    5586. 

  5586. 		} else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
    5587. 

  5587. 			ZVAL_UNDEFINED_OP2();
    5588. 

  5588. 			str = ZSTR_EMPTY_ALLOC();
    5589. 

  5589. 			ZEND_VM_C_GOTO(str_index);
    5590. 

  5590. 		} else {
    5591. 

  5591. 			zend_illegal_offset();
    5592. 

  5592. 			zval_ptr_dtor_nogc(expr_ptr);
    5593. 

  5593. 		}
    5594. 

  5594. 		FREE_OP2();
    5595. 

  5595. 	} else {
    5596. 

  5596. 		if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
    5597. 

  5597. 			zend_cannot_add_element();
    5598. 

  5598. 			zval_ptr_dtor_nogc(expr_ptr);
    5599. 

  5599. 		}
    5600. 

  5600. 	}
    5601. 

  5601. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5602. 

  5602. }
    5603. 

  5603. 

  5604. ZEND_VM_HANDLER(147, ZEND_ADD_ARRAY_UNPACK, ANY, ANY)
    5605. 

  5605. {
    5606. 

  5606. 	USE_OPLINE
    5607. 

  5607. 	zval *op1;
    5608. 

  5608. 

  5609. 	SAVE_OPLINE();
    5610. 

  5610. 	op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
    5611. 

  5611. 

  5612. ZEND_VM_C_LABEL(add_unpack_again):
    5613. 

  5613. 	if (EXPECTED(Z_TYPE_P(op1) == IS_ARRAY)) {
    5614. 

  5614. 		HashTable *ht = Z_ARRVAL_P(op1);
    5615. 

  5615. 		zval *val;
    5616. 

  5616. 		zend_string *key;
    5617. 

  5617. 

  5618. 		ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
    5619. 

  5619. 			if (key) {
    5620. 

  5620. 				zend_throw_error(NULL, "Cannot unpack array with string keys");
    5621. 

  5621. 				FREE_OP1();
    5622. 

  5622. 				HANDLE_EXCEPTION();
    5623. 

  5623. 			} else {
    5624. 

  5624. 				if (Z_ISREF_P(val) && Z_REFCOUNT_P(val) == 1) {
    5625. 

  5625. 					val = Z_REFVAL_P(val);
    5626. 

  5626. 				}
    5627. 

  5627. 				Z_TRY_ADDREF_P(val);
    5628. 

  5628. 				if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), val)) {
    5629. 

  5629. 					zend_cannot_add_element();
    5630. 

  5630. 					zval_ptr_dtor_nogc(val);
    5631. 

  5631. 					break;
    5632. 

  5632. 				}
    5633. 

  5633. 			}
    5634. 

  5634. 		} ZEND_HASH_FOREACH_END();
    5635. 

  5635. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
    5636. 

  5636. 		zend_class_entry *ce = Z_OBJCE_P(op1);
    5637. 

  5637. 		zend_object_iterator *iter;
    5638. 

  5638. 

  5639. 		if (!ce || !ce->get_iterator) {
    5640. 

  5640. 			zend_type_error("Only arrays and Traversables can be unpacked");
    5641. 

  5641. 		} else {
    5642. 

  5642. 			iter = ce->get_iterator(ce, op1, 0);
    5643. 

  5643. 			if (UNEXPECTED(!iter)) {
    5644. 

  5644. 				FREE_OP1();
    5645. 

  5645. 				if (!EG(exception)) {
    5646. 

  5646. 					zend_throw_exception_ex(
    5647. 

  5647. 						NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
    5648. 

  5648. 					);
    5649. 

  5649. 				}
    5650. 

  5650. 				HANDLE_EXCEPTION();
    5651. 

  5651. 			}
    5652. 

  5652. 

  5653. 			if (iter->funcs->rewind) {
    5654. 

  5654. 				iter->funcs->rewind(iter);
    5655. 

  5655. 			}
    5656. 

  5656. 

  5657. 			for (; iter->funcs->valid(iter) == SUCCESS; ) {
    5658. 

  5658. 				zval *val;
    5659. 

  5659. 

  5660. 				if (UNEXPECTED(EG(exception) != NULL)) {
    5661. 

  5661. 					break;
    5662. 

  5662. 				}
    5663. 

  5663. 

  5664. 				val = iter->funcs->get_current_data(iter);
    5665. 

  5665. 				if (UNEXPECTED(EG(exception) != NULL)) {
    5666. 

  5666. 					break;
    5667. 

  5667. 				}
    5668. 

  5668. 

  5669. 				if (iter->funcs->get_current_key) {
    5670. 

  5670. 					zval key;
    5671. 

  5671. 					iter->funcs->get_current_key(iter, &key);
    5672. 

  5672. 					if (UNEXPECTED(EG(exception) != NULL)) {
    5673. 

  5673. 						break;
    5674. 

  5674. 					}
    5675. 

  5675. 

  5676. 					if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) {
    5677. 

  5677. 						zend_throw_error(NULL,
    5678. 

  5678. 							(Z_TYPE(key) == IS_STRING) ?
    5679. 

  5679. 								"Cannot unpack Traversable with string keys" :
    5680. 

  5680. 								"Cannot unpack Traversable with non-integer keys");
    5681. 

  5681. 						zval_ptr_dtor(&key);
    5682. 

  5682. 						break;
    5683. 

  5683. 					}
    5684. 

  5684. 				}
    5685. 

  5685. 

  5686. 				ZVAL_DEREF(val);
    5687. 

  5687. 				Z_TRY_ADDREF_P(val);
    5688. 

  5688. 

  5689. 				if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), val)) {
    5690. 

  5690. 					zend_cannot_add_element();
    5691. 

  5691. 					zval_ptr_dtor_nogc(val);
    5692. 

  5692. 				}
    5693. 

  5693. 

  5694. 				iter->funcs->move_forward(iter);
    5695. 

  5695. 			}
    5696. 

  5696. 

  5697. 			zend_iterator_dtor(iter);
    5698. 

  5698. 		}
    5699. 

  5699. 	} else if (EXPECTED(Z_ISREF_P(op1))) {
    5700. 

  5700. 		op1 = Z_REFVAL_P(op1);
    5701. 

  5701. 		ZEND_VM_C_GOTO(add_unpack_again);
    5702. 

  5702. 	} else {
    5703. 

  5703. 		zend_throw_error(NULL, "Only arrays and Traversables can be unpacked");
    5704. 

  5704. 	}
    5705. 

  5705. 

  5706. 	FREE_OP1();
    5707. 

  5707. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5708. 

  5708. }
    5709. 

  5709. 

  5710. ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|CV|UNUSED, CONST|TMPVAR|UNUSED|NEXT|CV, ARRAY_INIT|REF)
    5711. 

  5711. {
    5712. 

  5712. 	zval *array;
    5713. 

  5713. 	uint32_t size;
    5714. 

  5714. 	USE_OPLINE
    5715. 

  5715. 

  5716. 	array = EX_VAR(opline->result.var);
    5717. 

  5717. 	if (OP1_TYPE != IS_UNUSED) {
    5718. 

  5718. 		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
    5719. 

  5719. 		ZVAL_ARR(array, zend_new_array(size));
    5720. 

  5720. 		/* Explicitly initialize array as not-packed if flag is set */
    5721. 

  5721. 		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
    5722. 

  5722. 			zend_hash_real_init_mixed(Z_ARRVAL_P(array));
    5723. 

  5723. 		}
    5724. 

  5724. 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ADD_ARRAY_ELEMENT);
    5725. 

  5725. 	} else {
    5726. 

  5726. 		ZVAL_ARR(array, zend_new_array(0));
    5727. 

  5727. 		ZEND_VM_NEXT_OPCODE();
    5728. 

  5728. 	}
    5729. 

  5729. }
    5730. 

  5730. 

  5731. ZEND_VM_COLD_CONST_HANDLER(51, ZEND_CAST, CONST|TMP|VAR|CV, ANY, TYPE)
    5732. 

  5732. {
    5733. 

  5733. 	USE_OPLINE
    5734. 

  5734. 	zval *expr;
    5735. 

  5735. 	zval *result = EX_VAR(opline->result.var);
    5736. 

  5736. 	HashTable *ht;
    5737. 

  5737. 

  5738. 	SAVE_OPLINE();
    5739. 

  5739. 	expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    5740. 

  5740. 

  5741. 	switch (opline->extended_value) {
    5742. 

  5742. 		case IS_LONG:
    5743. 

  5743. 			ZVAL_LONG(result, zval_get_long(expr));
    5744. 

  5744. 			break;
    5745. 

  5745. 		case IS_DOUBLE:
    5746. 

  5746. 			ZVAL_DOUBLE(result, zval_get_double(expr));
    5747. 

  5747. 			break;
    5748. 

  5748. 		case IS_STRING:
    5749. 

  5749. 			ZVAL_STR(result, zval_get_string(expr));
    5750. 

  5750. 			break;
    5751. 

  5751. 		default:
    5752. 

  5752. 			ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
    5753. 

  5753. 			if (OP1_TYPE & (IS_VAR|IS_CV)) {
    5754. 

  5754. 				ZVAL_DEREF(expr);
    5755. 

  5755. 			}
    5756. 

  5756. 			/* If value is already of correct type, return it directly */
    5757. 

  5757. 			if (Z_TYPE_P(expr) == opline->extended_value) {
    5758. 

  5758. 				ZVAL_COPY_VALUE(result, expr);
    5759. 

  5759. 				if (OP1_TYPE == IS_CONST) {
    5760. 

  5760. 					if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
    5761. 

  5761. 				} else if (OP1_TYPE != IS_TMP_VAR) {
    5762. 

  5762. 					if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
    5763. 

  5763. 				}
    5764. 

  5764. 

  5765. 				FREE_OP1_IF_VAR();
    5766. 

  5766. 				ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5767. 

  5767. 			}
    5768. 

  5768. 

  5769. 			if (opline->extended_value == IS_ARRAY) {
    5770. 

  5770. 				if (OP1_TYPE == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
    5771. 

  5771. 					if (Z_TYPE_P(expr) != IS_NULL) {
    5772. 

  5772. 						ZVAL_ARR(result, zend_new_array(1));
    5773. 

  5773. 						expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
    5774. 

  5774. 						if (OP1_TYPE == IS_CONST) {
    5775. 

  5775. 							if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
    5776. 

  5776. 						} else {
    5777. 

  5777. 							if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
    5778. 

  5778. 						}
    5779. 

  5779. 					} else {
    5780. 

  5780. 						ZVAL_EMPTY_ARRAY(result);
    5781. 

  5781. 					}
    5782. 

  5782. 				} else {
    5783. 

  5783. 					HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
    5784. 

  5784. 					if (obj_ht) {
    5785. 

  5785. 						/* fast copy */
    5786. 

  5786. 						ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
    5787. 

  5787. 							(Z_OBJCE_P(expr)->default_properties_count ||
    5788. 

  5788. 							 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
    5789. 

  5789. 							 GC_IS_RECURSIVE(obj_ht))));
    5790. 

  5790. 						zend_release_properties(obj_ht);
    5791. 

  5791. 					} else {
    5792. 

  5792. 						ZVAL_EMPTY_ARRAY(result);
    5793. 

  5793. 					}
    5794. 

  5794. 				}
    5795. 

  5795. 			} else {
    5796. 

  5796. 				ZEND_ASSERT(opline->extended_value == IS_OBJECT);
    5797. 

  5797. 				ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
    5798. 

  5798. 				if (Z_TYPE_P(expr) == IS_ARRAY) {
    5799. 

  5799. 					ht = zend_symtable_to_proptable(Z_ARR_P(expr));
    5800. 

  5800. 					if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
    5801. 

  5801. 						/* TODO: try not to duplicate immutable arrays as well ??? */
    5802. 

  5802. 						ht = zend_array_dup(ht);
    5803. 

  5803. 					}
    5804. 

  5804. 					Z_OBJ_P(result)->properties = ht;
    5805. 

  5805. 				} else if (Z_TYPE_P(expr) != IS_NULL) {
    5806. 

  5806. 					Z_OBJ_P(result)->properties = ht = zend_new_array(1);
    5807. 

  5807. 					expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
    5808. 

  5808. 					if (OP1_TYPE == IS_CONST) {
    5809. 

  5809. 						if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
    5810. 

  5810. 					} else {
    5811. 

  5811. 						if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
    5812. 

  5812. 					}
    5813. 

  5813. 				}
    5814. 

  5814. 			}
    5815. 

  5815. 	}
    5816. 

  5816. 

  5817. 	FREE_OP1();
    5818. 

  5818. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5819. 

  5819. }
    5820. 

  5820. 

  5821. ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL)
    5822. 

  5822. {
    5823. 

  5823. 	USE_OPLINE
    5824. 

  5824. 	zend_op_array *new_op_array;
    5825. 

  5825. 	zval *inc_filename;
    5826. 

  5826. 

  5827. 	SAVE_OPLINE();
    5828. 

  5828. 	inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R);
    5829. 

  5829. 	new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
    5830. 

  5830. 	FREE_OP1();
    5831. 

  5831. 	if (UNEXPECTED(EG(exception) != NULL)) {
    5832. 

  5832. 		if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
    5833. 

  5833. 			destroy_op_array(new_op_array);
    5834. 

  5834. 			efree_size(new_op_array, sizeof(zend_op_array));
    5835. 

  5835. 		}
    5836. 

  5836. 		UNDEF_RESULT();
    5837. 

  5837. 		HANDLE_EXCEPTION();
    5838. 

  5838. 	} else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
    5839. 

  5839. 		if (RETURN_VALUE_USED(opline)) {
    5840. 

  5840. 			ZVAL_TRUE(EX_VAR(opline->result.var));
    5841. 

  5841. 		}
    5842. 

  5842. 	} else if (EXPECTED(new_op_array != NULL)) {
    5843. 

  5843. 		zval *return_value = NULL;
    5844. 

  5844. 		zend_execute_data *call;
    5845. 

  5845. 

  5846. 		if (RETURN_VALUE_USED(opline)) {
    5847. 

  5847. 			return_value = EX_VAR(opline->result.var);
    5848. 

  5848. 		}
    5849. 

  5849. 

  5850. 		new_op_array->scope = EX(func)->op_array.scope;
    5851. 

  5851. 

  5852. 		call = zend_vm_stack_push_call_frame(
    5853. 

  5853. 		    (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
    5854. 

  5854. 			(zend_function*)new_op_array, 0,
    5855. 

  5855. 			Z_PTR(EX(This)));
    5856. 

  5856. 

  5857. 		if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
    5858. 

  5858. 			call->symbol_table = EX(symbol_table);
    5859. 

  5859. 		} else {
    5860. 

  5860. 			call->symbol_table = zend_rebuild_symbol_table();
    5861. 

  5861. 		}
    5862. 

  5862. 

  5863. 		call->prev_execute_data = execute_data;
    5864. 

  5864. 		i_init_code_execute_data(call, new_op_array, return_value);
    5865. 

  5865. 		if (EXPECTED(zend_execute_ex == execute_ex)) {
    5866. 

  5866. 			ZEND_VM_ENTER();
    5867. 

  5867. 		} else {
    5868. 

  5868. 			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
    5869. 

  5869. 			zend_execute_ex(call);
    5870. 

  5870. 			zend_vm_stack_free_call_frame(call);
    5871. 

  5871. 		}
    5872. 

  5872. 

  5873. 		destroy_op_array(new_op_array);
    5874. 

  5874. 		efree_size(new_op_array, sizeof(zend_op_array));
    5875. 

  5875. 		if (UNEXPECTED(EG(exception) != NULL)) {
    5876. 

  5876. 			zend_rethrow_exception(execute_data);
    5877. 

  5877. 			UNDEF_RESULT();
    5878. 

  5878. 			HANDLE_EXCEPTION();
    5879. 

  5879. 		}
    5880. 

  5880. 	} else if (RETURN_VALUE_USED(opline)) {
    5881. 

  5881. 		ZVAL_FALSE(EX_VAR(opline->result.var));
    5882. 

  5882. 	}
    5883. 

  5883. 	ZEND_VM_NEXT_OPCODE();
    5884. 

  5884. }
    5885. 

  5885. 

  5886. ZEND_VM_HANDLER(153, ZEND_UNSET_CV, CV, UNUSED)
    5887. 

  5887. {
    5888. 

  5888. 	USE_OPLINE
    5889. 

  5889. 	zval *var = EX_VAR(opline->op1.var);
    5890. 

  5890. 

  5891. 	if (Z_REFCOUNTED_P(var)) {
    5892. 

  5892. 		zend_refcounted *garbage = Z_COUNTED_P(var);
    5893. 

  5893. 

  5894. 		ZVAL_UNDEF(var);
    5895. 

  5895. 		SAVE_OPLINE();
    5896. 

  5896. 		if (!GC_DELREF(garbage)) {
    5897. 

  5897. 			rc_dtor_func(garbage);
    5898. 

  5898. 		} else {
    5899. 

  5899. 			gc_check_possible_root(garbage);
    5900. 

  5900. 		}
    5901. 

  5901. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5902. 

  5902. 	} else {
    5903. 

  5903. 		ZVAL_UNDEF(var);
    5904. 

  5904. 	}
    5905. 

  5905. 	ZEND_VM_NEXT_OPCODE();
    5906. 

  5906. }
    5907. 

  5907. 

  5908. ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
    5909. 

  5909. {
    5910. 

  5910. 	USE_OPLINE
    5911. 

  5911. 	zval *varname;
    5912. 

  5912. 	zend_string *name, *tmp_name;
    5913. 

  5913. 	HashTable *target_symbol_table;
    5914. 

  5914. 

  5915. 	SAVE_OPLINE();
    5916. 

  5916. 

  5917. 	varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    5918. 

  5918. 

  5919. 	if (OP1_TYPE == IS_CONST) {
    5920. 

  5920. 		name = Z_STR_P(varname);
    5921. 

  5921. 	} else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
    5922. 

  5922. 		name = Z_STR_P(varname);
    5923. 

  5923. 		tmp_name = NULL;
    5924. 

  5924. 	} else {
    5925. 

  5925. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
    5926. 

  5926. 			varname = ZVAL_UNDEFINED_OP1();
    5927. 

  5927. 		}
    5928. 

  5928. 		name = zval_try_get_tmp_string(varname, &tmp_name);
    5929. 

  5929. 		if (UNEXPECTED(!name)) {
    5930. 

  5930. 			FREE_OP1();
    5931. 

  5931. 			HANDLE_EXCEPTION();
    5932. 

  5932. 		}
    5933. 

  5933. 	}
    5934. 

  5934. 

  5935. 	target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
    5936. 

  5936. 	zend_hash_del_ind(target_symbol_table, name);
    5937. 

  5937. 

  5938. 	if (OP1_TYPE != IS_CONST) {
    5939. 

  5939. 		zend_tmp_string_release(tmp_name);
    5940. 

  5940. 	}
    5941. 

  5941. 	FREE_OP1();
    5942. 

  5942. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5943. 

  5943. }
    5944. 

  5944. 

  5945. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
    5946. 

  5946. ZEND_VM_COLD_HANDLER(179, ZEND_UNSET_STATIC_PROP, ANY, ANY, CACHE_SLOT)
    5947. 

  5947. {
    5948. 

  5948. 	USE_OPLINE
    5949. 

  5949. 	zval *varname;
    5950. 

  5950. 	zend_string *name, *tmp_name = NULL;
    5951. 

  5951. 	zend_class_entry *ce;
    5952. 

  5952. 

  5953. 	SAVE_OPLINE();
    5954. 

  5954. 

  5955. 	if (OP2_TYPE == IS_CONST) {
    5956. 

  5956. 		ce = CACHED_PTR(opline->extended_value);
    5957. 

  5957. 		if (UNEXPECTED(ce == NULL)) {
    5958. 

  5958. 			ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
    5959. 

  5959. 			if (UNEXPECTED(ce == NULL)) {
    5960. 

  5960. 				ZEND_ASSERT(EG(exception));
    5961. 

  5961. 				FREE_UNFETCHED_OP1();
    5962. 

  5962. 				HANDLE_EXCEPTION();
    5963. 

  5963. 			}
    5964. 

  5964. 			/*CACHE_PTR(opline->extended_value, ce);*/
    5965. 

  5965. 		}
    5966. 

  5966. 	} else if (OP2_TYPE == IS_UNUSED) {
    5967. 

  5967. 		ce = zend_fetch_class(NULL, opline->op2.num);
    5968. 

  5968. 		if (UNEXPECTED(ce == NULL)) {
    5969. 

  5969. 			ZEND_ASSERT(EG(exception));
    5970. 

  5970. 			FREE_UNFETCHED_OP1();
    5971. 

  5971. 			HANDLE_EXCEPTION();
    5972. 

  5972. 		}
    5973. 

  5973. 	} else {
    5974. 

  5974. 		ce = Z_CE_P(EX_VAR(opline->op2.var));
    5975. 

  5975. 	}
    5976. 

  5976. 

  5977. 	varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    5978. 

  5978. 	if (OP1_TYPE == IS_CONST) {
    5979. 

  5979. 		name = Z_STR_P(varname);
    5980. 

  5980. 	} else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
    5981. 

  5981. 		name = Z_STR_P(varname);
    5982. 

  5982. 	} else {
    5983. 

  5983. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
    5984. 

  5984. 			varname = ZVAL_UNDEFINED_OP1();
    5985. 

  5985. 		}
    5986. 

  5986. 		name = zval_try_get_tmp_string(varname, &tmp_name);
    5987. 

  5987. 		if (UNEXPECTED(!name)) {
    5988. 

  5988. 			FREE_OP1();
    5989. 

  5989. 			HANDLE_EXCEPTION();
    5990. 

  5990. 		}
    5991. 

  5991. 	}
    5992. 

  5992. 

  5993. 	zend_std_unset_static_property(ce, name);
    5994. 

  5994. 

  5995. 	zend_tmp_string_release(tmp_name);
    5996. 

  5996. 	FREE_OP1();
    5997. 

  5997. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    5998. 

  5998. }
    5999. 

  5999. 

  6000. ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|CV, CONST|TMPVAR|CV)
    6001. 

  6001. {
    6002. 

  6002. 	USE_OPLINE
    6003. 

  6003. 	zval *container;
    6004. 

  6004. 	zval *offset;
    6005. 

  6005. 	zend_ulong hval;
    6006. 

  6006. 	zend_string *key;
    6007. 

  6007. 

  6008. 	SAVE_OPLINE();
    6009. 

  6009. 	container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_UNSET);
    6010. 

  6010. 	offset = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    6011. 

  6011. 

  6012. 	do {
    6013. 

  6013. 		if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    6014. 

  6014. 			HashTable *ht;
    6015. 

  6015. 

  6016. ZEND_VM_C_LABEL(unset_dim_array):
    6017. 

  6017. 			SEPARATE_ARRAY(container);
    6018. 

  6018. 			ht = Z_ARRVAL_P(container);
    6019. 

  6019. ZEND_VM_C_LABEL(offset_again):
    6020. 

  6020. 			if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
    6021. 

  6021. 				key = Z_STR_P(offset);
    6022. 

  6022. 				if (OP2_TYPE != IS_CONST) {
    6023. 

  6023. 					if (ZEND_HANDLE_NUMERIC(key, hval)) {
    6024. 

  6024. 						ZEND_VM_C_GOTO(num_index_dim);
    6025. 

  6025. 					}
    6026. 

  6026. 				}
    6027. 

  6027. ZEND_VM_C_LABEL(str_index_dim):
    6028. 

  6028. 				if (ht == &EG(symbol_table)) {
    6029. 

  6029. 					zend_delete_global_variable(key);
    6030. 

  6030. 				} else {
    6031. 

  6031. 					zend_hash_del(ht, key);
    6032. 

  6032. 				}
    6033. 

  6033. 			} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
    6034. 

  6034. 				hval = Z_LVAL_P(offset);
    6035. 

  6035. ZEND_VM_C_LABEL(num_index_dim):
    6036. 

  6036. 				zend_hash_index_del(ht, hval);
    6037. 

  6037. 			} else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
    6038. 

  6038. 				offset = Z_REFVAL_P(offset);
    6039. 

  6039. 				ZEND_VM_C_GOTO(offset_again);
    6040. 

  6040. 			} else if (Z_TYPE_P(offset) == IS_DOUBLE) {
    6041. 

  6041. 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
    6042. 

  6042. 				ZEND_VM_C_GOTO(num_index_dim);
    6043. 

  6043. 			} else if (Z_TYPE_P(offset) == IS_NULL) {
    6044. 

  6044. 				key = ZSTR_EMPTY_ALLOC();
    6045. 

  6045. 				ZEND_VM_C_GOTO(str_index_dim);
    6046. 

  6046. 			} else if (Z_TYPE_P(offset) == IS_FALSE) {
    6047. 

  6047. 				hval = 0;
    6048. 

  6048. 				ZEND_VM_C_GOTO(num_index_dim);
    6049. 

  6049. 			} else if (Z_TYPE_P(offset) == IS_TRUE) {
    6050. 

  6050. 				hval = 1;
    6051. 

  6051. 				ZEND_VM_C_GOTO(num_index_dim);
    6052. 

  6052. 			} else if (Z_TYPE_P(offset) == IS_RESOURCE) {
    6053. 

  6053. 				hval = Z_RES_HANDLE_P(offset);
    6054. 

  6054. 				ZEND_VM_C_GOTO(num_index_dim);
    6055. 

  6055. 			} else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
    6056. 

  6056. 				ZVAL_UNDEFINED_OP2();
    6057. 

  6057. 				key = ZSTR_EMPTY_ALLOC();
    6058. 

  6058. 				ZEND_VM_C_GOTO(str_index_dim);
    6059. 

  6059. 			} else {
    6060. 

  6060. 				zend_type_error("Illegal offset type in unset");
    6061. 

  6061. 			}
    6062. 

  6062. 			break;
    6063. 

  6063. 		} else if (Z_ISREF_P(container)) {
    6064. 

  6064. 			container = Z_REFVAL_P(container);
    6065. 

  6065. 			if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    6066. 

  6066. 				ZEND_VM_C_GOTO(unset_dim_array);
    6067. 

  6067. 			}
    6068. 

  6068. 		}
    6069. 

  6069. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
    6070. 

  6070. 			container = ZVAL_UNDEFINED_OP1();
    6071. 

  6071. 		}
    6072. 

  6072. 		if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
    6073. 

  6073. 			offset = ZVAL_UNDEFINED_OP2();
    6074. 

  6074. 		}
    6075. 

  6075. 		if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
    6076. 

  6076. 			if (OP2_TYPE == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
    6077. 

  6077. 				offset++;
    6078. 

  6078. 			}
    6079. 

  6079. 			Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
    6080. 

  6080. 		} else if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
    6081. 

  6081. 			zend_throw_error(NULL, "Cannot unset string offsets");
    6082. 

  6082. 		}
    6083. 

  6083. 	} while (0);
    6084. 

  6084. 

  6085. 	FREE_OP2();
    6086. 

  6086. 	FREE_OP1_VAR_PTR();
    6087. 

  6087. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    6088. 

  6088. }
    6089. 

  6089. 

  6090. ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
    6091. 

  6091. {
    6092. 

  6092. 	USE_OPLINE
    6093. 

  6093. 	zval *container;
    6094. 

  6094. 	zval *offset;
    6095. 

  6095. 	zend_string *name, *tmp_name;
    6096. 

  6096. 

  6097. 	SAVE_OPLINE();
    6098. 

  6098. 	container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_UNSET);
    6099. 

  6099. 	offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
    6100. 

  6100. 

  6101. 	do {
    6102. 

  6102. 		if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
    6103. 

  6103. 			if (Z_ISREF_P(container)) {
    6104. 

  6104. 				container = Z_REFVAL_P(container);
    6105. 

  6105. 				if (Z_TYPE_P(container) != IS_OBJECT) {
    6106. 

  6106. 					if (OP1_TYPE == IS_CV
    6107. 

  6107. 					 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
    6108. 

  6108. 						ZVAL_UNDEFINED_OP1();
    6109. 

  6109. 					}
    6110. 

  6110. 					break;
    6111. 

  6111. 				}
    6112. 

  6112. 			} else {
    6113. 

  6113. 				break;
    6114. 

  6114. 			}
    6115. 

  6115. 		}
    6116. 

  6116. 		if (OP2_TYPE == IS_CONST) {
    6117. 

  6117. 			name = Z_STR_P(offset);
    6118. 

  6118. 		} else {
    6119. 

  6119. 			name = zval_try_get_tmp_string(offset, &tmp_name);
    6120. 

  6120. 			if (UNEXPECTED(!name)) {
    6121. 

  6121. 				break;
    6122. 

  6122. 			}
    6123. 

  6123. 		}
    6124. 

  6124. 		Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
    6125. 

  6125. 		if (OP2_TYPE != IS_CONST) {
    6126. 

  6126. 			zend_tmp_string_release(tmp_name);
    6127. 

  6127. 		}
    6128. 

  6128. 	} while (0);
    6129. 

  6129. 

  6130. 	FREE_OP2();
    6131. 

  6131. 	FREE_OP1_VAR_PTR();
    6132. 

  6132. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    6133. 

  6133. }
    6134. 

  6134. 

  6135. ZEND_VM_HANDLER(77, ZEND_FE_RESET_R, CONST|TMP|VAR|CV, JMP_ADDR)
    6136. 

  6136. {
    6137. 

  6137. 	USE_OPLINE
    6138. 

  6138. 	zval *array_ptr, *result;
    6139. 

  6139. 

  6140. 	SAVE_OPLINE();
    6141. 

  6141. 

  6142. 	array_ptr = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
    6143. 

  6143. 	if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
    6144. 

  6144. 		result = EX_VAR(opline->result.var);
    6145. 

  6145. 		ZVAL_COPY_VALUE(result, array_ptr);
    6146. 

  6146. 		if (OP1_TYPE != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
    6147. 

  6147. 			Z_ADDREF_P(array_ptr);
    6148. 

  6148. 		}
    6149. 

  6149. 		Z_FE_POS_P(result) = 0;
    6150. 

  6150. 

  6151. 		FREE_OP1_IF_VAR();
    6152. 

  6152. 		ZEND_VM_NEXT_OPCODE();
    6153. 

  6153. 	} else if (OP1_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
    6154. 

  6154. 		zend_object *zobj = Z_OBJ_P(array_ptr);
    6155. 

  6155. 		if (!zobj->ce->get_iterator) {
    6156. 

  6156. 			HashTable *properties;
    6157. 

  6157. 

  6158. 			result = EX_VAR(opline->result.var);
    6159. 

  6159. 			ZVAL_OBJ(result, zobj);
    6160. 

  6160. 			if (OP1_TYPE != IS_TMP_VAR) {
    6161. 

  6161. 				GC_ADDREF(zobj);
    6162. 

  6162. 			}
    6163. 

  6163. 			properties = zobj->properties;
    6164. 

  6164. 			if (properties) {
    6165. 

  6165. 				if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
    6166. 

  6166. 					if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
    6167. 

  6167. 						GC_DELREF(properties);
    6168. 

  6168. 					}
    6169. 

  6169. 					properties = zobj->properties = zend_array_dup(properties);
    6170. 

  6170. 				}
    6171. 

  6171. 			} else {
    6172. 

  6172. 				properties = zobj->handlers->get_properties(zobj);
    6173. 

  6173. 			}
    6174. 

  6174. 			Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
    6175. 

  6175. 

  6176. 			FREE_OP1_IF_VAR();
    6177. 

  6177. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    6178. 

  6178. 		} else {
    6179. 

  6179. 			zend_bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
    6180. 

  6180. 

  6181. 			FREE_OP1();
    6182. 

  6182. 			if (UNEXPECTED(EG(exception))) {
    6183. 

  6183. 				HANDLE_EXCEPTION();
    6184. 

  6184. 			} else if (is_empty) {
    6185. 

  6185. 				ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    6186. 

  6186. 			} else {
    6187. 

  6187. 				ZEND_VM_NEXT_OPCODE();
    6188. 

  6188. 			}
    6189. 

  6189. 		}
    6190. 

  6190. 	} else {
    6191. 

  6191. 		zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
    6192. 

  6192. 		ZVAL_UNDEF(EX_VAR(opline->result.var));
    6193. 

  6193. 		Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
    6194. 

  6194. 		FREE_OP1();
    6195. 

  6195. 		ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
    6196. 

  6196. 	}
    6197. 

  6197. }
    6198. 

  6198. 

  6199. ZEND_VM_COLD_CONST_HANDLER(125, ZEND_FE_RESET_RW, CONST|TMP|VAR|CV, JMP_ADDR)
    6200. 

  6200. {
    6201. 

  6201. 	USE_OPLINE
    6202. 

  6202. 	zval *array_ptr, *array_ref;
    6203. 

  6203. 

  6204. 	SAVE_OPLINE();
    6205. 

  6205. 

  6206. 	if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
    6207. 

  6207. 		array_ref = array_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
    6208. 

  6208. 		if (Z_ISREF_P(array_ref)) {
    6209. 

  6209. 			array_ptr = Z_REFVAL_P(array_ref);
    6210. 

  6210. 		}
    6211. 

  6211. 	} else {
    6212. 

  6212. 		array_ref = array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    6213. 

  6213. 	}
    6214. 

  6214. 

  6215. 	if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
    6216. 

  6216. 		if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
    6217. 

  6217. 			if (array_ptr == array_ref) {
    6218. 

  6218. 				ZVAL_NEW_REF(array_ref, array_ref);
    6219. 

  6219. 				array_ptr = Z_REFVAL_P(array_ref);
    6220. 

  6220. 			}
    6221. 

  6221. 			Z_ADDREF_P(array_ref);
    6222. 

  6222. 			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
    6223. 

  6223. 		} else {
    6224. 

  6224. 			array_ref = EX_VAR(opline->result.var);
    6225. 

  6225. 			ZVAL_NEW_REF(array_ref, array_ptr);
    6226. 

  6226. 			array_ptr = Z_REFVAL_P(array_ref);
    6227. 

  6227. 		}
    6228. 

  6228. 		if (OP1_TYPE == IS_CONST) {
    6229. 

  6229. 			ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
    6230. 

  6230. 		} else {
    6231. 

  6231. 			SEPARATE_ARRAY(array_ptr);
    6232. 

  6232. 		}
    6233. 

  6233. 		Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
    6234. 

  6234. 

  6235. 		if (OP1_TYPE == IS_VAR) {
    6236. 

  6236. 			FREE_OP1_VAR_PTR();
    6237. 

  6237. 		}
    6238. 

  6238. 		ZEND_VM_NEXT_OPCODE();
    6239. 

  6239. 	} else if (OP1_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
    6240. 

  6240. 		if (!Z_OBJCE_P(array_ptr)->get_iterator) {
    6241. 

  6241. 			if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
    6242. 

  6242. 				if (array_ptr == array_ref) {
    6243. 

  6243. 					ZVAL_NEW_REF(array_ref, array_ref);
    6244. 

  6244. 					array_ptr = Z_REFVAL_P(array_ref);
    6245. 

  6245. 				}
    6246. 

  6246. 				Z_ADDREF_P(array_ref);
    6247. 

  6247. 				ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
    6248. 

  6248. 			} else {
    6249. 

  6249. 				array_ptr = EX_VAR(opline->result.var);
    6250. 

  6250. 				ZVAL_COPY_VALUE(array_ptr, array_ref);
    6251. 

  6251. 			}
    6252. 

  6252. 			if (Z_OBJ_P(array_ptr)->properties
    6253. 

  6253. 			 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
    6254. 

  6254. 				if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
    6255. 

  6255. 					GC_DELREF(Z_OBJ_P(array_ptr)->properties);
    6256. 

  6256. 				}
    6257. 

  6257. 				Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
    6258. 

  6258. 			}
    6259. 

  6259. 			Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_OBJPROP_P(array_ptr), 0);
    6260. 

  6260. 

  6261. 			FREE_OP1_VAR_PTR();
    6262. 

  6262. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    6263. 

  6263. 		} else {
    6264. 

  6264. 			zend_bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
    6265. 

  6265. 

  6266. 			if (OP1_TYPE == IS_VAR) {
    6267. 

  6267. 				FREE_OP1_VAR_PTR();
    6268. 

  6268. 			} else {
    6269. 

  6269. 				FREE_OP1();
    6270. 

  6270. 			}
    6271. 

  6271. 			if (UNEXPECTED(EG(exception))) {
    6272. 

  6272. 				HANDLE_EXCEPTION();
    6273. 

  6273. 			} else if (is_empty) {
    6274. 

  6274. 				ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    6275. 

  6275. 			} else {
    6276. 

  6276. 				ZEND_VM_NEXT_OPCODE();
    6277. 

  6277. 			}
    6278. 

  6278. 		}
    6279. 

  6279. 	} else {
    6280. 

  6280. 		zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
    6281. 

  6281. 		ZVAL_UNDEF(EX_VAR(opline->result.var));
    6282. 

  6282. 		Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
    6283. 

  6283. 		if (OP1_TYPE == IS_VAR) {
    6284. 

  6284. 			FREE_OP1_VAR_PTR();
    6285. 

  6285. 		} else {
    6286. 

  6286. 			FREE_OP1();
    6287. 

  6287. 		}
    6288. 

  6288. 		ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
    6289. 

  6289. 	}
    6290. 

  6290. }
    6291. 

  6291. 

  6292. ZEND_VM_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY, JMP_ADDR)
    6293. 

  6293. {
    6294. 

  6294. 	USE_OPLINE
    6295. 

  6295. 	zval *array;
    6296. 

  6296. 	zval *value;
    6297. 

  6297. 	uint32_t value_type;
    6298. 

  6298. 	HashTable *fe_ht;
    6299. 

  6299. 	HashPosition pos;
    6300. 

  6300. 	Bucket *p;
    6301. 

  6301. 

  6302. 	array = EX_VAR(opline->op1.var);
    6303. 

  6303. 	SAVE_OPLINE();
    6304. 

  6304. 	if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
    6305. 

  6305. 		fe_ht = Z_ARRVAL_P(array);
    6306. 

  6306. 		pos = Z_FE_POS_P(array);
    6307. 

  6307. 		p = fe_ht->arData + pos;
    6308. 

  6308. 		while (1) {
    6309. 

  6309. 			if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
    6310. 

  6310. 				/* reached end of iteration */
    6311. 

  6311. ZEND_VM_C_LABEL(fe_fetch_r_exit):
    6312. 

  6312. 				ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
    6313. 

  6313. 				ZEND_VM_CONTINUE();
    6314. 

  6314. 			}
    6315. 

  6315. 			value = &p->val;
    6316. 

  6316. 			value_type = Z_TYPE_INFO_P(value);
    6317. 

  6317. 			if (EXPECTED(value_type != IS_UNDEF)) {
    6318. 

  6318. 				if (UNEXPECTED(value_type == IS_INDIRECT)) {
    6319. 

  6319. 					value = Z_INDIRECT_P(value);
    6320. 

  6320. 					value_type = Z_TYPE_INFO_P(value);
    6321. 

  6321. 					if (EXPECTED(value_type != IS_UNDEF)) {
    6322. 

  6322. 						break;
    6323. 

  6323. 					}
    6324. 

  6324. 				} else {
    6325. 

  6325. 					break;
    6326. 

  6326. 				}
    6327. 

  6327. 			}
    6328. 

  6328. 			pos++;
    6329. 

  6329. 			p++;
    6330. 

  6330. 		}
    6331. 

  6331. 		Z_FE_POS_P(array) = pos + 1;
    6332. 

  6332. 		if (RETURN_VALUE_USED(opline)) {
    6333. 

  6333. 			if (!p->key) {
    6334. 

  6334. 				ZVAL_LONG(EX_VAR(opline->result.var), p->h);
    6335. 

  6335. 			} else {
    6336. 

  6336. 				ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
    6337. 

  6337. 			}
    6338. 

  6338. 		}
    6339. 

  6339. 	} else {
    6340. 

  6340. 		zend_object_iterator *iter;
    6341. 

  6341. 

  6342. 		ZEND_ASSERT(Z_TYPE_P(array) == IS_OBJECT);
    6343. 

  6343. 		if ((iter = zend_iterator_unwrap(array)) == NULL) {
    6344. 

  6344. 			/* plain object */
    6345. 

  6345. 

  6346. 			fe_ht = Z_OBJPROP_P(array);
    6347. 

  6347. 			pos = zend_hash_iterator_pos(Z_FE_ITER_P(array), fe_ht);
    6348. 

  6348. 			p = fe_ht->arData + pos;
    6349. 

  6349. 			while (1) {
    6350. 

  6350. 				if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
    6351. 

  6351. 					/* reached end of iteration */
    6352. 

  6352. 					ZEND_VM_C_GOTO(fe_fetch_r_exit);
    6353. 

  6353. 				}
    6354. 

  6354. 

  6355. 				value = &p->val;
    6356. 

  6356. 				value_type = Z_TYPE_INFO_P(value);
    6357. 

  6357. 				if (EXPECTED(value_type != IS_UNDEF)) {
    6358. 

  6358. 					if (UNEXPECTED(value_type == IS_INDIRECT)) {
    6359. 

  6359. 						value = Z_INDIRECT_P(value);
    6360. 

  6360. 						value_type = Z_TYPE_INFO_P(value);
    6361. 

  6361. 						if (EXPECTED(value_type != IS_UNDEF)
    6362. 

  6362. 						 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
    6363. 

  6363. 							break;
    6364. 

  6364. 						}
    6365. 

  6365. 					} else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
    6366. 

  6366. 							|| !p->key
    6367. 

  6367. 							|| zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
    6368. 

  6368. 						break;
    6369. 

  6369. 					}
    6370. 

  6370. 				}
    6371. 

  6371. 				pos++;
    6372. 

  6372. 				p++;
    6373. 

  6373. 			}
    6374. 

  6374. 			if (RETURN_VALUE_USED(opline)) {
    6375. 

  6375. 				if (UNEXPECTED(!p->key)) {
    6376. 

  6376. 					ZVAL_LONG(EX_VAR(opline->result.var), p->h);
    6377. 

  6377. 				} else if (ZSTR_VAL(p->key)[0]) {
    6378. 

  6378. 					ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
    6379. 

  6379. 				} else {
    6380. 

  6380. 					const char *class_name, *prop_name;
    6381. 

  6381. 					size_t prop_name_len;
    6382. 

  6382. 					zend_unmangle_property_name_ex(
    6383. 

  6383. 						p->key, &class_name, &prop_name, &prop_name_len);
    6384. 

  6384. 					ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
    6385. 

  6385. 				}
    6386. 

  6386. 			}
    6387. 

  6387. 			EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos + 1;
    6388. 

  6388. 		} else {
    6389. 

  6389. 			if (EXPECTED(++iter->index > 0)) {
    6390. 

  6390. 				/* This could cause an endless loop if index becomes zero again.
    6391. 

  6391. 				 * In case that ever happens we need an additional flag. */
    6392. 

  6392. 				iter->funcs->move_forward(iter);
    6393. 

  6393. 				if (UNEXPECTED(EG(exception) != NULL)) {
    6394. 

  6394. 					UNDEF_RESULT();
    6395. 

  6395. 					HANDLE_EXCEPTION();
    6396. 

  6396. 				}
    6397. 

  6397. 				if (UNEXPECTED(iter->funcs->valid(iter) == FAILURE)) {
    6398. 

  6398. 					/* reached end of iteration */
    6399. 

  6399. 					if (UNEXPECTED(EG(exception) != NULL)) {
    6400. 

  6400. 						UNDEF_RESULT();
    6401. 

  6401. 						HANDLE_EXCEPTION();
    6402. 

  6402. 					}
    6403. 

  6403. 					ZEND_VM_C_GOTO(fe_fetch_r_exit);
    6404. 

  6404. 				}
    6405. 

  6405. 			}
    6406. 

  6406. 			value = iter->funcs->get_current_data(iter);
    6407. 

  6407. 			if (UNEXPECTED(EG(exception) != NULL)) {
    6408. 

  6408. 				UNDEF_RESULT();
    6409. 

  6409. 				HANDLE_EXCEPTION();
    6410. 

  6410. 			}
    6411. 

  6411. 			if (!value) {
    6412. 

  6412. 				/* failure in get_current_data */
    6413. 

  6413. 				ZEND_VM_C_GOTO(fe_fetch_r_exit);
    6414. 

  6414. 			}
    6415. 

  6415. 			if (RETURN_VALUE_USED(opline)) {
    6416. 

  6416. 				if (iter->funcs->get_current_key) {
    6417. 

  6417. 					iter->funcs->get_current_key(iter, EX_VAR(opline->result.var));
    6418. 

  6418. 					if (UNEXPECTED(EG(exception) != NULL)) {
    6419. 

  6419. 						UNDEF_RESULT();
    6420. 

  6420. 						HANDLE_EXCEPTION();
    6421. 

  6421. 					}
    6422. 

  6422. 				} else {
    6423. 

  6423. 					ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
    6424. 

  6424. 				}
    6425. 

  6425. 			}
    6426. 

  6426. 			value_type = Z_TYPE_INFO_P(value);
    6427. 

  6427. 		}
    6428. 

  6428. 	}
    6429. 

  6429. 

  6430. 	if (EXPECTED(OP2_TYPE == IS_CV)) {
    6431. 

  6431. 		zval *variable_ptr = EX_VAR(opline->op2.var);
    6432. 

  6432. 		zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
    6433. 

  6433. 	} else {
    6434. 

  6434. 		zval *res = EX_VAR(opline->op2.var);
    6435. 

  6435. 		zend_refcounted *gc = Z_COUNTED_P(value);
    6436. 

  6436. 

  6437. 		ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
    6438. 

  6438. 		if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
    6439. 

  6439. 			GC_ADDREF(gc);
    6440. 

  6440. 		}
    6441. 

  6441. 	}
    6442. 

  6442. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    6443. 

  6443. }
    6444. 

  6444. 

  6445. ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR)
    6446. 

  6446. {
    6447. 

  6447. 	USE_OPLINE
    6448. 

  6448. 	zval *array;
    6449. 

  6449. 	zval *value;
    6450. 

  6450. 	uint32_t value_type;
    6451. 

  6451. 	HashTable *fe_ht;
    6452. 

  6452. 	HashPosition pos;
    6453. 

  6453. 	Bucket *p;
    6454. 

  6454. 

  6455. 	array = EX_VAR(opline->op1.var);
    6456. 

  6456. 	SAVE_OPLINE();
    6457. 

  6457. 

  6458. 	ZVAL_DEREF(array);
    6459. 

  6459. 	if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
    6460. 

  6460. 		pos = zend_hash_iterator_pos_ex(Z_FE_ITER_P(EX_VAR(opline->op1.var)), array);
    6461. 

  6461. 		fe_ht = Z_ARRVAL_P(array);
    6462. 

  6462. 		p = fe_ht->arData + pos;
    6463. 

  6463. 		while (1) {
    6464. 

  6464. 			if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
    6465. 

  6465. 				/* reached end of iteration */
    6466. 

  6466. 				ZEND_VM_C_GOTO(fe_fetch_w_exit);
    6467. 

  6467. 			}
    6468. 

  6468. 			value = &p->val;
    6469. 

  6469. 			value_type = Z_TYPE_INFO_P(value);
    6470. 

  6470. 			if (EXPECTED(value_type != IS_UNDEF)) {
    6471. 

  6471. 				if (UNEXPECTED(value_type == IS_INDIRECT)) {
    6472. 

  6472. 					value = Z_INDIRECT_P(value);
    6473. 

  6473. 					value_type = Z_TYPE_INFO_P(value);
    6474. 

  6474. 					if (EXPECTED(value_type != IS_UNDEF)) {
    6475. 

  6475. 						break;
    6476. 

  6476. 					}
    6477. 

  6477. 				} else {
    6478. 

  6478. 					break;
    6479. 

  6479. 				}
    6480. 

  6480. 			}
    6481. 

  6481. 			pos++;
    6482. 

  6482. 			p++;
    6483. 

  6483. 		}
    6484. 

  6484. 		if (RETURN_VALUE_USED(opline)) {
    6485. 

  6485. 			if (!p->key) {
    6486. 

  6486. 				ZVAL_LONG(EX_VAR(opline->result.var), p->h);
    6487. 

  6487. 			} else {
    6488. 

  6488. 				ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
    6489. 

  6489. 			}
    6490. 

  6490. 		}
    6491. 

  6491. 		EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1;
    6492. 

  6492. 	} else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
    6493. 

  6493. 		zend_object_iterator *iter;
    6494. 

  6494. 

  6495. 		if ((iter = zend_iterator_unwrap(array)) == NULL) {
    6496. 

  6496. 			/* plain object */
    6497. 

  6497. 

  6498. 			fe_ht = Z_OBJPROP_P(array);
    6499. 

  6499. 			pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
    6500. 

  6500. 			p = fe_ht->arData + pos;
    6501. 

  6501. 			while (1) {
    6502. 

  6502. 				if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
    6503. 

  6503. 					/* reached end of iteration */
    6504. 

  6504. 					ZEND_VM_C_GOTO(fe_fetch_w_exit);
    6505. 

  6505. 				}
    6506. 

  6506. 

  6507. 				value = &p->val;
    6508. 

  6508. 				value_type = Z_TYPE_INFO_P(value);
    6509. 

  6509. 				if (EXPECTED(value_type != IS_UNDEF)) {
    6510. 

  6510. 					if (UNEXPECTED(value_type == IS_INDIRECT)) {
    6511. 

  6511. 						value = Z_INDIRECT_P(value);
    6512. 

  6512. 						value_type = Z_TYPE_INFO_P(value);
    6513. 

  6513. 						if (EXPECTED(value_type != IS_UNDEF)
    6514. 

  6514. 						 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
    6515. 

  6515. 							if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
    6516. 

  6516. 								zend_property_info *prop_info =
    6517. 

  6517. 									zend_get_typed_property_info_for_slot(Z_OBJ_P(array), value);
    6518. 

  6518. 								if (UNEXPECTED(prop_info)) {
    6519. 

  6519. 									ZVAL_NEW_REF(value, value);
    6520. 

  6520. 									ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
    6521. 

  6521. 									value_type = IS_REFERENCE_EX;
    6522. 

  6522. 								}
    6523. 

  6523. 							}
    6524. 

  6524. 							break;
    6525. 

  6525. 						}
    6526. 

  6526. 					} else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
    6527. 

  6527. 							|| !p->key
    6528. 

  6528. 							|| zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
    6529. 

  6529. 						break;
    6530. 

  6530. 					}
    6531. 

  6531. 				}
    6532. 

  6532. 				pos++;
    6533. 

  6533. 				p++;
    6534. 

  6534. 			}
    6535. 

  6535. 			if (RETURN_VALUE_USED(opline)) {
    6536. 

  6536. 				if (UNEXPECTED(!p->key)) {
    6537. 

  6537. 					ZVAL_LONG(EX_VAR(opline->result.var), p->h);
    6538. 

  6538. 				} else if (ZSTR_VAL(p->key)[0]) {
    6539. 

  6539. 					ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
    6540. 

  6540. 				} else {
    6541. 

  6541. 					const char *class_name, *prop_name;
    6542. 

  6542. 					size_t prop_name_len;
    6543. 

  6543. 					zend_unmangle_property_name_ex(
    6544. 

  6544. 						p->key, &class_name, &prop_name, &prop_name_len);
    6545. 

  6545. 					ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
    6546. 

  6546. 				}
    6547. 

  6547. 			}
    6548. 

  6548. 			EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1;
    6549. 

  6549. 		} else {
    6550. 

  6550. 			if (++iter->index > 0) {
    6551. 

  6551. 				/* This could cause an endless loop if index becomes zero again.
    6552. 

  6552. 				 * In case that ever happens we need an additional flag. */
    6553. 

  6553. 				iter->funcs->move_forward(iter);
    6554. 

  6554. 				if (UNEXPECTED(EG(exception) != NULL)) {
    6555. 

  6555. 					UNDEF_RESULT();
    6556. 

  6556. 					HANDLE_EXCEPTION();
    6557. 

  6557. 				}
    6558. 

  6558. 				if (UNEXPECTED(iter->funcs->valid(iter) == FAILURE)) {
    6559. 

  6559. 					/* reached end of iteration */
    6560. 

  6560. 					if (UNEXPECTED(EG(exception) != NULL)) {
    6561. 

  6561. 						UNDEF_RESULT();
    6562. 

  6562. 						HANDLE_EXCEPTION();
    6563. 

  6563. 					}
    6564. 

  6564. 					ZEND_VM_C_GOTO(fe_fetch_w_exit);
    6565. 

  6565. 				}
    6566. 

  6566. 			}
    6567. 

  6567. 			value = iter->funcs->get_current_data(iter);
    6568. 

  6568. 			if (UNEXPECTED(EG(exception) != NULL)) {
    6569. 

  6569. 				UNDEF_RESULT();
    6570. 

  6570. 				HANDLE_EXCEPTION();
    6571. 

  6571. 			}
    6572. 

  6572. 			if (!value) {
    6573. 

  6573. 				/* failure in get_current_data */
    6574. 

  6574. 				ZEND_VM_C_GOTO(fe_fetch_w_exit);
    6575. 

  6575. 			}
    6576. 

  6576. 			if (RETURN_VALUE_USED(opline)) {
    6577. 

  6577. 				if (iter->funcs->get_current_key) {
    6578. 

  6578. 					iter->funcs->get_current_key(iter, EX_VAR(opline->result.var));
    6579. 

  6579. 					if (UNEXPECTED(EG(exception) != NULL)) {
    6580. 

  6580. 						UNDEF_RESULT();
    6581. 

  6581. 						HANDLE_EXCEPTION();
    6582. 

  6582. 					}
    6583. 

  6583. 				} else {
    6584. 

  6584. 					ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
    6585. 

  6585. 				}
    6586. 

  6586. 			}
    6587. 

  6587. 			value_type = Z_TYPE_INFO_P(value);
    6588. 

  6588. 		}
    6589. 

  6589. 	} else {
    6590. 

  6590. 		zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array)));
    6591. 

  6591. 		if (UNEXPECTED(EG(exception))) {
    6592. 

  6592. 			UNDEF_RESULT();
    6593. 

  6593. 			HANDLE_EXCEPTION();
    6594. 

  6594. 		}
    6595. 

  6595. ZEND_VM_C_LABEL(fe_fetch_w_exit):
    6596. 

  6596. 		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
    6597. 

  6597. 		ZEND_VM_CONTINUE();
    6598. 

  6598. 	}
    6599. 

  6599. 

  6600. 	if (EXPECTED((value_type & Z_TYPE_MASK) != IS_REFERENCE)) {
    6601. 

  6601. 		zend_refcounted *gc = Z_COUNTED_P(value);
    6602. 

  6602. 		zval *ref;
    6603. 

  6603. 		ZVAL_NEW_EMPTY_REF(value);
    6604. 

  6604. 		ref = Z_REFVAL_P(value);
    6605. 

  6605. 		ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
    6606. 

  6606. 	}
    6607. 

  6607. 	if (EXPECTED(OP2_TYPE == IS_CV)) {
    6608. 

  6608. 		zval *variable_ptr = EX_VAR(opline->op2.var);
    6609. 

  6609. 		if (EXPECTED(variable_ptr != value)) {
    6610. 

  6610. 			zend_reference *ref;
    6611. 

  6611. 

  6612. 			ref = Z_REF_P(value);
    6613. 

  6613. 			GC_ADDREF(ref);
    6614. 

  6614. 			i_zval_ptr_dtor(variable_ptr);
    6615. 

  6615. 			ZVAL_REF(variable_ptr, ref);
    6616. 

  6616. 		}
    6617. 

  6617. 	} else {
    6618. 

  6618. 		Z_ADDREF_P(value);
    6619. 

  6619. 		ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value));
    6620. 

  6620. 	}
    6621. 

  6621. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    6622. 

  6622. }
    6623. 

  6623. 

  6624. ZEND_VM_HOT_HANDLER(154, ZEND_ISSET_ISEMPTY_CV, CV, UNUSED, ISSET, SPEC(ISSET))
    6625. 

  6625. {
    6626. 

  6626. 	USE_OPLINE
    6627. 

  6627. 	zval *value;
    6628. 

  6628. 

  6629. 	value = EX_VAR(opline->op1.var);
    6630. 

  6630. 	if (!(opline->extended_value & ZEND_ISEMPTY)) {
    6631. 

  6631. 		if (Z_TYPE_P(value) > IS_NULL &&
    6632. 

  6632. 		    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
    6633. 

  6633. 			ZEND_VM_SMART_BRANCH_TRUE();
    6634. 

  6634. 		} else {
    6635. 

  6635. 			ZEND_VM_SMART_BRANCH_FALSE();
    6636. 

  6636. 		}
    6637. 

  6637. 	} else {
    6638. 

  6638. 		int result;
    6639. 

  6639. 

  6640. 		SAVE_OPLINE();
    6641. 

  6641. 		result = !i_zend_is_true(value);
    6642. 

  6642. 		ZEND_VM_SMART_BRANCH(result, 1);
    6643. 

  6643. 	}
    6644. 

  6644. }
    6645. 

  6645. 

  6646. ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|ISSET)
    6647. 

  6647. {
    6648. 

  6648. 	USE_OPLINE
    6649. 

  6649. 	zval *value;
    6650. 

  6650. 	int result;
    6651. 

  6651. 	zval *varname;
    6652. 

  6652. 	zend_string *name, *tmp_name;
    6653. 

  6653. 	HashTable *target_symbol_table;
    6654. 

  6654. 

  6655. 	SAVE_OPLINE();
    6656. 

  6656. 	varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
    6657. 

  6657. 	if (OP1_TYPE == IS_CONST) {
    6658. 

  6658. 		name = Z_STR_P(varname);
    6659. 

  6659. 	} else {
    6660. 

  6660. 		name = zval_get_tmp_string(varname, &tmp_name);
    6661. 

  6661. 	}
    6662. 

  6662. 

  6663. 	target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
    6664. 

  6664. 	value = zend_hash_find_ex(target_symbol_table, name, OP1_TYPE == IS_CONST);
    6665. 

  6665. 

  6666. 	if (OP1_TYPE != IS_CONST) {
    6667. 

  6667. 		zend_tmp_string_release(tmp_name);
    6668. 

  6668. 	}
    6669. 

  6669. 	FREE_OP1();
    6670. 

  6670. 

  6671. 	if (!value) {
    6672. 

  6672. 		result = (opline->extended_value & ZEND_ISEMPTY);
    6673. 

  6673. 	} else {
    6674. 

  6674. 		if (Z_TYPE_P(value) == IS_INDIRECT) {
    6675. 

  6675. 			value = Z_INDIRECT_P(value);
    6676. 

  6676. 		}
    6677. 

  6677. 		if (!(opline->extended_value & ZEND_ISEMPTY)) {
    6678. 

  6678. 			if (Z_ISREF_P(value)) {
    6679. 

  6679. 				value = Z_REFVAL_P(value);
    6680. 

  6680. 			}
    6681. 

  6681. 			result = Z_TYPE_P(value) > IS_NULL;
    6682. 

  6682. 		} else {
    6683. 

  6683. 			result = !i_zend_is_true(value);
    6684. 

  6684. 		}
    6685. 

  6685. 	}
    6686. 

  6686. 

  6687. 	ZEND_VM_SMART_BRANCH(result, 1);
    6688. 

  6688. }
    6689. 

  6689. 

  6690. /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
    6691. 

  6691. ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, ANY, CLASS_FETCH, ISSET|CACHE_SLOT)
    6692. 

  6692. {
    6693. 

  6693. 	USE_OPLINE
    6694. 

  6694. 	zval *value;
    6695. 

  6695. 	int result;
    6696. 

  6696. 

  6697. 	SAVE_OPLINE();
    6698. 

  6698. 

  6699. 	result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
    6700. 

  6700. 

  6701. 	if (!(opline->extended_value & ZEND_ISEMPTY)) {
    6702. 

  6702. 		result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
    6703. 

  6703. 		    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
    6704. 

  6704. 	} else {
    6705. 

  6705. 		result = result != SUCCESS || !i_zend_is_true(value);
    6706. 

  6706. 	}
    6707. 

  6707. 

  6708. 	ZEND_VM_SMART_BRANCH(result, 1);
    6709. 

  6709. }
    6710. 

  6710. 

  6711. ZEND_VM_COLD_CONSTCONST_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMPVAR|CV, CONST|TMPVAR|CV, ISSET)
    6712. 

  6712. {
    6713. 

  6713. 	USE_OPLINE
    6714. 

  6714. 	zval *container;
    6715. 

  6715. 	int result;
    6716. 

  6716. 	zend_ulong hval;
    6717. 

  6717. 	zval *offset;
    6718. 

  6718. 

  6719. 	SAVE_OPLINE();
    6720. 

  6720. 	container = GET_OP1_OBJ_ZVAL_PTR_UNDEF(BP_VAR_IS);
    6721. 

  6721. 	offset = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    6722. 

  6722. 

  6723. 	if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    6724. 

  6724. 		HashTable *ht;
    6725. 

  6725. 		zval *value;
    6726. 

  6726. 		zend_string *str;
    6727. 

  6727. 

  6728. ZEND_VM_C_LABEL(isset_dim_obj_array):
    6729. 

  6729. 		ht = Z_ARRVAL_P(container);
    6730. 

  6730. ZEND_VM_C_LABEL(isset_again):
    6731. 

  6731. 		if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
    6732. 

  6732. 			str = Z_STR_P(offset);
    6733. 

  6733. 			if (OP2_TYPE != IS_CONST) {
    6734. 

  6734. 				if (ZEND_HANDLE_NUMERIC(str, hval)) {
    6735. 

  6735. 					ZEND_VM_C_GOTO(num_index_prop);
    6736. 

  6736. 				}
    6737. 

  6737. 			}
    6738. 

  6738. 			value = zend_hash_find_ex_ind(ht, str, OP2_TYPE == IS_CONST);
    6739. 

  6739. 		} else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
    6740. 

  6740. 			hval = Z_LVAL_P(offset);
    6741. 

  6741. ZEND_VM_C_LABEL(num_index_prop):
    6742. 

  6742. 			value = zend_hash_index_find(ht, hval);
    6743. 

  6743. 		} else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
    6744. 

  6744. 			offset = Z_REFVAL_P(offset);
    6745. 

  6745. 			ZEND_VM_C_GOTO(isset_again);
    6746. 

  6746. 		} else {
    6747. 

  6747. 			value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
    6748. 

  6748. 			if (UNEXPECTED(EG(exception))) {
    6749. 

  6749. 				result = 0;
    6750. 

  6750. 				ZEND_VM_C_GOTO(isset_dim_obj_exit);
    6751. 

  6751. 			}
    6752. 

  6752. 		}
    6753. 

  6753. 

  6754. 		if (!(opline->extended_value & ZEND_ISEMPTY)) {
    6755. 

  6755. 			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
    6756. 

  6756. 			result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
    6757. 

  6757. 			    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
    6758. 

  6758. 

  6759. 			if (OP1_TYPE & (IS_CONST|IS_CV)) {
    6760. 

  6760. 				/* avoid exception check */
    6761. 

  6761. 				FREE_OP2();
    6762. 

  6762. 				ZEND_VM_SMART_BRANCH(result, 0);
    6763. 

  6763. 			}
    6764. 

  6764. 		} else {
    6765. 

  6765. 			result = (value == NULL || !i_zend_is_true(value));
    6766. 

  6766. 		}
    6767. 

  6767. 		ZEND_VM_C_GOTO(isset_dim_obj_exit);
    6768. 

  6768. 	} else if ((OP1_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
    6769. 

  6769. 		container = Z_REFVAL_P(container);
    6770. 

  6770. 		if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    6771. 

  6771. 			ZEND_VM_C_GOTO(isset_dim_obj_array);
    6772. 

  6772. 		}
    6773. 

  6773. 	}
    6774. 

  6774. 

  6775. 	if (OP2_TYPE == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
    6776. 

  6776. 		offset++;
    6777. 

  6777. 	}
    6778. 

  6778. 	if (!(opline->extended_value & ZEND_ISEMPTY)) {
    6779. 

  6779. 		result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
    6780. 

  6780. 	} else {
    6781. 

  6781. 		result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
    6782. 

  6782. 	}
    6783. 

  6783. 

  6784. ZEND_VM_C_LABEL(isset_dim_obj_exit):
    6785. 

  6785. 	FREE_OP2();
    6786. 

  6786. 	FREE_OP1();
    6787. 

  6787. 	ZEND_VM_SMART_BRANCH(result, 1);
    6788. 

  6788. }
    6789. 

  6789. 

  6790. ZEND_VM_COLD_CONST_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, ISSET|CACHE_SLOT)
    6791. 

  6791. {
    6792. 

  6792. 	USE_OPLINE
    6793. 

  6793. 	zval *container;
    6794. 

  6794. 	int result;
    6795. 

  6795. 	zval *offset;
    6796. 

  6796. 	zend_string *name, *tmp_name;
    6797. 

  6797. 

  6798. 	SAVE_OPLINE();
    6799. 

  6799. 	container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
    6800. 

  6800. 	offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
    6801. 

  6801. 

  6802. 	if (OP1_TYPE == IS_CONST ||
    6803. 

  6803. 	    (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
    6804. 

  6804. 		if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
    6805. 

  6805. 			container = Z_REFVAL_P(container);
    6806. 

  6806. 			if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
    6807. 

  6807. 				result = (opline->extended_value & ZEND_ISEMPTY);
    6808. 

  6808. 				ZEND_VM_C_GOTO(isset_object_finish);
    6809. 

  6809. 			}
    6810. 

  6810. 		} else {
    6811. 

  6811. 			result = (opline->extended_value & ZEND_ISEMPTY);
    6812. 

  6812. 			ZEND_VM_C_GOTO(isset_object_finish);
    6813. 

  6813. 		}
    6814. 

  6814. 	}
    6815. 

  6815. 

  6816. 	if (OP2_TYPE == IS_CONST) {
    6817. 

  6817. 		name = Z_STR_P(offset);
    6818. 

  6818. 	} else {
    6819. 

  6819. 		name = zval_try_get_tmp_string(offset, &tmp_name);
    6820. 

  6820. 		if (UNEXPECTED(!name)) {
    6821. 

  6821. 			result = 0;
    6822. 

  6822. 			ZEND_VM_C_GOTO(isset_object_finish);
    6823. 

  6823. 		}
    6824. 

  6824. 	}
    6825. 

  6825. 

  6826. 	result =
    6827. 

  6827. 		(opline->extended_value & ZEND_ISEMPTY) ^
    6828. 

  6828. 		Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
    6829. 

  6829. 

  6830. 	if (OP2_TYPE != IS_CONST) {
    6831. 

  6831. 		zend_tmp_string_release(tmp_name);
    6832. 

  6832. 	}
    6833. 

  6833. 

  6834. ZEND_VM_C_LABEL(isset_object_finish):
    6835. 

  6835. 	FREE_OP2();
    6836. 

  6836. 	FREE_OP1();
    6837. 

  6837. 	ZEND_VM_SMART_BRANCH(result, 1);
    6838. 

  6838. }
    6839. 

  6839. 

  6840. ZEND_VM_HANDLER(194, ZEND_ARRAY_KEY_EXISTS, CV|TMPVAR|CONST, CV|TMPVAR|CONST)
    6841. 

  6841. {
    6842. 

  6842. 	USE_OPLINE
    6843. 

  6843. 

  6844. 	zval *key, *subject;
    6845. 

  6845. 	HashTable *ht;
    6846. 

  6846. 	zend_bool result;
    6847. 

  6847. 

  6848. 	SAVE_OPLINE();
    6849. 

  6849. 

  6850. 	key = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    6851. 

  6851. 	subject = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    6852. 

  6852. 

  6853. 	if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
    6854. 

  6854. ZEND_VM_C_LABEL(array_key_exists_array):
    6855. 

  6855. 		ht = Z_ARRVAL_P(subject);
    6856. 

  6856. 		result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
    6857. 

  6857. 	} else {
    6858. 

  6858. 		if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
    6859. 

  6859. 			subject = Z_REFVAL_P(subject);
    6860. 

  6860. 			if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
    6861. 

  6861. 				ZEND_VM_C_GOTO(array_key_exists_array);
    6862. 

  6862. 			}
    6863. 

  6863. 		}
    6864. 

  6864. 		zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
    6865. 

  6865. 		result = 0;
    6866. 

  6866. 	}
    6867. 

  6867. 

  6868. 	FREE_OP2();
    6869. 

  6869. 	FREE_OP1();
    6870. 

  6870. 	ZEND_VM_SMART_BRANCH(result, 1);
    6871. 

  6871. }
    6872. 

  6872. 

  6873. /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
    6874. 

  6874. ZEND_VM_COLD_HANDLER(79, ZEND_EXIT, ANY, ANY)
    6875. 

  6875. {
    6876. 

  6876. 	USE_OPLINE
    6877. 

  6877. 

  6878. 	SAVE_OPLINE();
    6879. 

  6879. 	if (OP1_TYPE != IS_UNUSED) {
    6880. 

  6880. 		zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
    6881. 

  6881. 

  6882. 		do {
    6883. 

  6883. 			if (Z_TYPE_P(ptr) == IS_LONG) {
    6884. 

  6884. 				EG(exit_status) = Z_LVAL_P(ptr);
    6885. 

  6885. 			} else {
    6886. 

  6886. 				if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) {
    6887. 

  6887. 					ptr = Z_REFVAL_P(ptr);
    6888. 

  6888. 					if (Z_TYPE_P(ptr) == IS_LONG) {
    6889. 

  6889. 						EG(exit_status) = Z_LVAL_P(ptr);
    6890. 

  6890. 						break;
    6891. 

  6891. 					}
    6892. 

  6892. 				}
    6893. 

  6893. 				zend_print_zval(ptr, 0);
    6894. 

  6894. 			}
    6895. 

  6895. 		} while (0);
    6896. 

  6896. 		FREE_OP1();
    6897. 

  6897. 	}
    6898. 

  6898. 	zend_bailout();
    6899. 

  6899. 	ZEND_VM_NEXT_OPCODE(); /* Never reached */
    6900. 

  6900. }
    6901. 

  6901. 

  6902. ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
    6903. 

  6903. {
    6904. 

  6904. 	USE_OPLINE
    6905. 

  6905. 

  6906. 	ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
    6907. 

  6907. 

  6908. 	if (!E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))) {
    6909. 

  6909. 		do {
    6910. 

  6910. 			/* Do not silence fatal errors */
    6911. 

  6911. 			EG(error_reporting) &= E_FATAL_ERRORS;
    6912. 

  6912. 			if (!EG(error_reporting_ini_entry)) {
    6913. 

  6913. 				zval *zv = zend_hash_find_ex(EG(ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING), 1);
    6914. 

  6914. 				if (zv) {
    6915. 

  6915. 					EG(error_reporting_ini_entry) = (zend_ini_entry *)Z_PTR_P(zv);
    6916. 

  6916. 				} else {
    6917. 

  6917. 					break;
    6918. 

  6918. 				}
    6919. 

  6919. 			}
    6920. 

  6920. 			if (!EG(error_reporting_ini_entry)->modified) {
    6921. 

  6921. 				if (!EG(modified_ini_directives)) {
    6922. 

  6922. 					ALLOC_HASHTABLE(EG(modified_ini_directives));
    6923. 

  6923. 					zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
    6924. 

  6924. 				}
    6925. 

  6925. 				if (EXPECTED(zend_hash_add_ptr(EG(modified_ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING), EG(error_reporting_ini_entry)) != NULL)) {
    6926. 

  6926. 					EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
    6927. 

  6927. 					EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
    6928. 

  6928. 					EG(error_reporting_ini_entry)->modified = 1;
    6929. 

  6929. 				}
    6930. 

  6930. 			}
    6931. 

  6931. 		} while (0);
    6932. 

  6932. 	}
    6933. 

  6933. 	ZEND_VM_NEXT_OPCODE();
    6934. 

  6934. }
    6935. 

  6935. 

  6936. ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
    6937. 

  6937. {
    6938. 

  6938. 	USE_OPLINE
    6939. 

  6939. 

  6940. 	if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))
    6941. 

  6941. 			&& !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) {
    6942. 

  6942. 		EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
    6943. 

  6943. 	}
    6944. 

  6944. 	ZEND_VM_NEXT_OPCODE();
    6945. 

  6945. }
    6946. 

  6946. 

  6947. ZEND_VM_COLD_CONST_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, JMP_ADDR)
    6948. 

  6948. {
    6949. 

  6949. 	USE_OPLINE
    6950. 

  6950. 	zval *value;
    6951. 

  6951. 	zval *ref = NULL;
    6952. 

  6952. 	int ret;
    6953. 

  6953. 

  6954. 	SAVE_OPLINE();
    6955. 

  6955. 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
    6956. 

  6956. 

  6957. 	if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && Z_ISREF_P(value)) {
    6958. 

  6958. 		if (OP1_TYPE == IS_VAR) {
    6959. 

  6959. 			ref = value;
    6960. 

  6960. 		}
    6961. 

  6961. 		value = Z_REFVAL_P(value);
    6962. 

  6962. 	}
    6963. 

  6963. 

  6964. 	ret = i_zend_is_true(value);
    6965. 

  6965. 

  6966. 	if (UNEXPECTED(EG(exception))) {
    6967. 

  6967. 		FREE_OP1();
    6968. 

  6968. 		ZVAL_UNDEF(EX_VAR(opline->result.var));
    6969. 

  6969. 		HANDLE_EXCEPTION();
    6970. 

  6970. 	}
    6971. 

  6971. 

  6972. 	if (ret) {
    6973. 

  6973. 		zval *result = EX_VAR(opline->result.var);
    6974. 

  6974. 

  6975. 		ZVAL_COPY_VALUE(result, value);
    6976. 

  6976. 		if (OP1_TYPE == IS_CONST) {
    6977. 

  6977. 			if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
    6978. 

  6978. 		} else if (OP1_TYPE == IS_CV) {
    6979. 

  6979. 			if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
    6980. 

  6980. 		} else if (OP1_TYPE == IS_VAR && ref) {
    6981. 

  6981. 			zend_reference *r = Z_REF_P(ref);
    6982. 

  6982. 

  6983. 			if (UNEXPECTED(GC_DELREF(r) == 0)) {
    6984. 

  6984. 				efree_size(r, sizeof(zend_reference));
    6985. 

  6985. 			} else if (Z_OPT_REFCOUNTED_P(result)) {
    6986. 

  6986. 				Z_ADDREF_P(result);
    6987. 

  6987. 			}
    6988. 

  6988. 		}
    6989. 

  6989. 		ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    6990. 

  6990. 	}
    6991. 

  6991. 

  6992. 	FREE_OP1();
    6993. 

  6993. 	ZEND_VM_NEXT_OPCODE();
    6994. 

  6994. }
    6995. 

  6995. 

  6996. ZEND_VM_COLD_CONST_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, JMP_ADDR)
    6997. 

  6997. {
    6998. 

  6998. 	USE_OPLINE
    6999. 

  6999. 	zval *value;
    7000. 

  7000. 	zval *ref = NULL;
    7001. 

  7001. 

  7002. 	SAVE_OPLINE();
    7003. 

  7003. 	value = GET_OP1_ZVAL_PTR(BP_VAR_IS);
    7004. 

  7004. 

  7005. 	if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
    7006. 

  7006. 		if (OP1_TYPE & IS_VAR) {
    7007. 

  7007. 			ref = value;
    7008. 

  7008. 		}
    7009. 

  7009. 		value = Z_REFVAL_P(value);
    7010. 

  7010. 	}
    7011. 

  7011. 

  7012. 	if (Z_TYPE_P(value) > IS_NULL) {
    7013. 

  7013. 		zval *result = EX_VAR(opline->result.var);
    7014. 

  7014. 		ZVAL_COPY_VALUE(result, value);
    7015. 

  7015. 		if (OP1_TYPE == IS_CONST) {
    7016. 

  7016. 			if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
    7017. 

  7017. 		} else if (OP1_TYPE == IS_CV) {
    7018. 

  7018. 			if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
    7019. 

  7019. 		} else if ((OP1_TYPE & IS_VAR) && ref) {
    7020. 

  7020. 			zend_reference *r = Z_REF_P(ref);
    7021. 

  7021. 

  7022. 			if (UNEXPECTED(GC_DELREF(r) == 0)) {
    7023. 

  7023. 				efree_size(r, sizeof(zend_reference));
    7024. 

  7024. 			} else if (Z_OPT_REFCOUNTED_P(result)) {
    7025. 

  7025. 				Z_ADDREF_P(result);
    7026. 

  7026. 			}
    7027. 

  7027. 		}
    7028. 

  7028. 		ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
    7029. 

  7029. 	}
    7030. 

  7030. 

  7031. 	FREE_OP1();
    7032. 

  7032. 	ZEND_VM_NEXT_OPCODE();
    7033. 

  7033. }
    7034. 

  7034. 

  7035. ZEND_VM_HOT_HANDLER(31, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
    7036. 

  7036. {
    7037. 

  7037. 	USE_OPLINE
    7038. 

  7038. 	zval *value;
    7039. 

  7039. 	zval *result = EX_VAR(opline->result.var);
    7040. 

  7040. 

  7041. 	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    7042. 

  7042. 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
    7043. 

  7043. 		SAVE_OPLINE();
    7044. 

  7044. 		ZVAL_UNDEFINED_OP1();
    7045. 

  7045. 		ZVAL_NULL(result);
    7046. 

  7046. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7047. 

  7047. 	}
    7048. 

  7048. 

  7049. 	if (OP1_TYPE == IS_CV) {
    7050. 

  7050. 		ZVAL_COPY_DEREF(result, value);
    7051. 

  7051. 	} else if (OP1_TYPE == IS_VAR) {
    7052. 

  7052. 		if (UNEXPECTED(Z_ISREF_P(value))) {
    7053. 

  7053. 			ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
    7054. 

  7054. 			if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
    7055. 

  7055. 				efree_size(Z_REF_P(value), sizeof(zend_reference));
    7056. 

  7056. 			} else if (Z_OPT_REFCOUNTED_P(result)) {
    7057. 

  7057. 				Z_ADDREF_P(result);
    7058. 

  7058. 			}
    7059. 

  7059. 		} else {
    7060. 

  7060. 			ZVAL_COPY_VALUE(result, value);
    7061. 

  7061. 		}
    7062. 

  7062. 	} else {
    7063. 

  7063. 		ZVAL_COPY_VALUE(result, value);
    7064. 

  7064. 		if (OP1_TYPE == IS_CONST) {
    7065. 

  7065. 			if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
    7066. 

  7066. 				Z_ADDREF_P(result);
    7067. 

  7067. 			}
    7068. 

  7068. 		}
    7069. 

  7069. 	}
    7070. 

  7070. 	ZEND_VM_NEXT_OPCODE();
    7071. 

  7071. }
    7072. 

  7072. 

  7073. ZEND_VM_COLD_HANDLER(101, ZEND_EXT_STMT, ANY, ANY)
    7074. 

  7074. {
    7075. 

  7075. 	USE_OPLINE
    7076. 

  7076. 

  7077. 	if (!EG(no_extensions)) {
    7078. 

  7078. 		SAVE_OPLINE();
    7079. 

  7079. 		zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, execute_data);
    7080. 

  7080. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7081. 

  7081. 	}
    7082. 

  7082. 	ZEND_VM_NEXT_OPCODE();
    7083. 

  7083. }
    7084. 

  7084. 

  7085. ZEND_VM_COLD_HANDLER(102, ZEND_EXT_FCALL_BEGIN, ANY, ANY)
    7086. 

  7086. {
    7087. 

  7087. 	USE_OPLINE
    7088. 

  7088. 

  7089. 	if (!EG(no_extensions)) {
    7090. 

  7090. 		SAVE_OPLINE();
    7091. 

  7091. 		zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, execute_data);
    7092. 

  7092. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7093. 

  7093. 	}
    7094. 

  7094. 	ZEND_VM_NEXT_OPCODE();
    7095. 

  7095. }
    7096. 

  7096. 

  7097. ZEND_VM_COLD_HANDLER(103, ZEND_EXT_FCALL_END, ANY, ANY)
    7098. 

  7098. {
    7099. 

  7099. 	USE_OPLINE
    7100. 

  7100. 

  7101. 	if (!EG(no_extensions)) {
    7102. 

  7102. 		SAVE_OPLINE();
    7103. 

  7103. 		zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, execute_data);
    7104. 

  7104. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7105. 

  7105. 	}
    7106. 

  7106. 	ZEND_VM_NEXT_OPCODE();
    7107. 

  7107. }
    7108. 

  7108. 

  7109. ZEND_VM_HANDLER(144, ZEND_DECLARE_CLASS, CONST, ANY)
    7110. 

  7110. {
    7111. 

  7111. 	USE_OPLINE
    7112. 

  7112. 

  7113. 	SAVE_OPLINE();
    7114. 

  7114. 	do_bind_class(RT_CONSTANT(opline, opline->op1), (OP2_TYPE == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL);
    7115. 

  7115. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7116. 

  7116. }
    7117. 

  7117. 

  7118. ZEND_VM_HANDLER(145, ZEND_DECLARE_CLASS_DELAYED, CONST, CONST)
    7119. 

  7119. {
    7120. 

  7120. 	USE_OPLINE
    7121. 

  7121. 	zval *lcname, *zv;
    7122. 

  7122. 	zend_class_entry *ce;
    7123. 

  7123. 

  7124. 	ce = CACHED_PTR(opline->extended_value);
    7125. 

  7125. 	if (ce == NULL) {
    7126. 

  7126. 		lcname = RT_CONSTANT(opline, opline->op1);
    7127. 

  7127. 		zv = zend_hash_find_ex(EG(class_table), Z_STR_P(lcname + 1), 1);
    7128. 

  7128. 		if (zv) {
    7129. 

  7129. 			SAVE_OPLINE();
    7130. 

  7130. 			ce = Z_CE_P(zv);
    7131. 

  7131. 			zv = zend_hash_set_bucket_key(EG(class_table), (Bucket*)zv, Z_STR_P(lcname));
    7132. 

  7132. 			if (UNEXPECTED(!zv)) {
    7133. 

  7133. 				zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name));
    7134. 

  7134. 			} else {
    7135. 

  7135. 				if (zend_do_link_class(ce, Z_STR_P(RT_CONSTANT(opline, opline->op2))) == FAILURE) {
    7136. 

  7136. 					/* Reload bucket pointer, the hash table may have been reallocated */
    7137. 

  7137. 					zv = zend_hash_find(EG(class_table), Z_STR_P(lcname));
    7138. 

  7138. 					zend_hash_set_bucket_key(EG(class_table), (Bucket *) zv, Z_STR_P(lcname + 1));
    7139. 

  7139. 					HANDLE_EXCEPTION();
    7140. 

  7140. 				}
    7141. 

  7141. 			}
    7142. 

  7142. 		}
    7143. 

  7143. 		CACHE_PTR(opline->extended_value, ce);
    7144. 

  7144. 	}
    7145. 

  7145. 	ZEND_VM_NEXT_OPCODE();
    7146. 

  7146. }
    7147. 

  7147. 

  7148. ZEND_VM_HANDLER(146, ZEND_DECLARE_ANON_CLASS, ANY, ANY, CACHE_SLOT)
    7149. 

  7149. {
    7150. 

  7150. 	zval *zv;
    7151. 

  7151. 	zend_class_entry *ce;
    7152. 

  7152. 	USE_OPLINE
    7153. 

  7153. 

  7154. 	ce = CACHED_PTR(opline->extended_value);
    7155. 

  7155. 	if (UNEXPECTED(ce == NULL)) {
    7156. 

  7156. 		zend_string *rtd_key = Z_STR_P(RT_CONSTANT(opline, opline->op1));
    7157. 

  7157. 		zv = zend_hash_find_ex(EG(class_table), rtd_key, 1);
    7158. 

  7158. 		if (UNEXPECTED(zv == NULL)) {
    7159. 

  7159. 			SAVE_OPLINE();
    7160. 

  7160. 			do {
    7161. 

  7161. 				ZEND_ASSERT(EX(func)->op_array.fn_flags & ZEND_ACC_PRELOADED);
    7162. 

  7162. 				if (zend_preload_autoload
    7163. 

  7163. 				  && zend_preload_autoload(EX(func)->op_array.filename) == SUCCESS) {
    7164. 

  7164. 					zv = zend_hash_find_ex(EG(class_table), rtd_key, 1);
    7165. 

  7165. 					if (EXPECTED(zv != NULL)) {
    7166. 

  7166. 						break;
    7167. 

  7167. 					}
    7168. 

  7168. 				}
    7169. 

  7169. 				zend_error_noreturn(E_ERROR, "Anonymous class wasn't preloaded");
    7170. 

  7170. 			} while (0);
    7171. 

  7171. 		}
    7172. 

  7172. 		ZEND_ASSERT(zv != NULL);
    7173. 

  7173. 		ce = Z_CE_P(zv);
    7174. 

  7174. 		if (!(ce->ce_flags & ZEND_ACC_LINKED)) {
    7175. 

  7175. 			SAVE_OPLINE();
    7176. 

  7176. 			if (zend_do_link_class(ce, (OP2_TYPE == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL) == FAILURE) {
    7177. 

  7177. 				HANDLE_EXCEPTION();
    7178. 

  7178. 			}
    7179. 

  7179. 		}
    7180. 

  7180. 		CACHE_PTR(opline->extended_value, ce);
    7181. 

  7181. 	}
    7182. 

  7182. 	Z_CE_P(EX_VAR(opline->result.var)) = ce;
    7183. 

  7183. 	ZEND_VM_NEXT_OPCODE();
    7184. 

  7184. }
    7185. 

  7185. 

  7186. ZEND_VM_HANDLER(141, ZEND_DECLARE_FUNCTION, ANY, ANY)
    7187. 

  7187. {
    7188. 

  7188. 	USE_OPLINE
    7189. 

  7189. 

  7190. 	SAVE_OPLINE();
    7191. 

  7191. 	do_bind_function(RT_CONSTANT(opline, opline->op1));
    7192. 

  7192. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7193. 

  7193. }
    7194. 

  7194. 

  7195. ZEND_VM_HANDLER(105, ZEND_TICKS, ANY, ANY, NUM)
    7196. 

  7196. {
    7197. 

  7197. 	USE_OPLINE
    7198. 

  7198. 

  7199. 	if ((uint32_t)++EG(ticks_count) >= opline->extended_value) {
    7200. 

  7200. 		EG(ticks_count) = 0;
    7201. 

  7201. 		if (zend_ticks_function) {
    7202. 

  7202. 			SAVE_OPLINE();
    7203. 

  7203. 			zend_ticks_function(opline->extended_value);
    7204. 

  7204. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7205. 

  7205. 		}
    7206. 

  7206. 	}
    7207. 

  7207. 	ZEND_VM_NEXT_OPCODE();
    7208. 

  7208. }
    7209. 

  7209. 

  7210. ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
    7211. 

  7211. {
    7212. 

  7212. 	USE_OPLINE
    7213. 

  7213. 	zval *expr;
    7214. 

  7214. 	zend_bool result;
    7215. 

  7215. 

  7216. 	SAVE_OPLINE();
    7217. 

  7217. 	expr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    7218. 

  7218. 

  7219. ZEND_VM_C_LABEL(try_instanceof):
    7220. 

  7220. 	if (Z_TYPE_P(expr) == IS_OBJECT) {
    7221. 

  7221. 		zend_class_entry *ce;
    7222. 

  7222. 

  7223. 		if (OP2_TYPE == IS_CONST) {
    7224. 

  7224. 			ce = CACHED_PTR(opline->extended_value);
    7225. 

  7225. 			if (UNEXPECTED(ce == NULL)) {
    7226. 

  7226. 				ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD);
    7227. 

  7227. 				if (EXPECTED(ce)) {
    7228. 

  7228. 					CACHE_PTR(opline->extended_value, ce);
    7229. 

  7229. 				}
    7230. 

  7230. 			}
    7231. 

  7231. 		} else if (OP2_TYPE == IS_UNUSED) {
    7232. 

  7232. 			ce = zend_fetch_class(NULL, opline->op2.num);
    7233. 

  7233. 			if (UNEXPECTED(ce == NULL)) {
    7234. 

  7234. 				ZEND_ASSERT(EG(exception));
    7235. 

  7235. 				FREE_OP1();
    7236. 

  7236. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    7237. 

  7237. 				HANDLE_EXCEPTION();
    7238. 

  7238. 			}
    7239. 

  7239. 		} else {
    7240. 

  7240. 			ce = Z_CE_P(EX_VAR(opline->op2.var));
    7241. 

  7241. 		}
    7242. 

  7242. 		result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
    7243. 

  7243. 	} else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
    7244. 

  7244. 		expr = Z_REFVAL_P(expr);
    7245. 

  7245. 		ZEND_VM_C_GOTO(try_instanceof);
    7246. 

  7246. 	} else {
    7247. 

  7247. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
    7248. 

  7248. 			ZVAL_UNDEFINED_OP1();
    7249. 

  7249. 		}
    7250. 

  7250. 		result = 0;
    7251. 

  7251. 	}
    7252. 

  7252. 	FREE_OP1();
    7253. 

  7253. 	ZEND_VM_SMART_BRANCH(result, 1);
    7254. 

  7254. }
    7255. 

  7255. 

  7256. ZEND_VM_HOT_HANDLER(104, ZEND_EXT_NOP, ANY, ANY)
    7257. 

  7257. {
    7258. 

  7258. 	USE_OPLINE
    7259. 

  7259. 

  7260. 	ZEND_VM_NEXT_OPCODE();
    7261. 

  7261. }
    7262. 

  7262. 

  7263. ZEND_VM_HOT_HANDLER(0, ZEND_NOP, ANY, ANY)
    7264. 

  7264. {
    7265. 

  7265. 	USE_OPLINE
    7266. 

  7266. 

  7267. 	ZEND_VM_NEXT_OPCODE();
    7268. 

  7268. }
    7269. 

  7269. 

  7270. ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_catch_offset, uint32_t op_num)
    7271. 

  7271. {
    7272. 

  7272. 	/* May be NULL during generator closing (only finally blocks are executed) */
    7273. 

  7273. 	zend_object *ex = EG(exception);
    7274. 

  7274. 

  7275. 	/* Walk try/catch/finally structures upwards, performing the necessary actions */
    7276. 

  7276. 	while (try_catch_offset != (uint32_t) -1) {
    7277. 

  7277. 		zend_try_catch_element *try_catch =
    7278. 

  7278. 			&EX(func)->op_array.try_catch_array[try_catch_offset];
    7279. 

  7279. 

  7280. 		if (op_num < try_catch->catch_op && ex) {
    7281. 

  7281. 			/* Go to catch block */
    7282. 

  7282. 			cleanup_live_vars(execute_data, op_num, try_catch->catch_op);
    7283. 

  7283. 			ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->catch_op], 0);
    7284. 

  7284. 

  7285. 		} else if (op_num < try_catch->finally_op) {
    7286. 

  7286. 			/* Go to finally block */
    7287. 

  7287. 			zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
    7288. 

  7288. 			cleanup_live_vars(execute_data, op_num, try_catch->finally_op);
    7289. 

  7289. 			Z_OBJ_P(fast_call) = EG(exception);
    7290. 

  7290. 			EG(exception) = NULL;
    7291. 

  7291. 			Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1;
    7292. 

  7292. 			ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->finally_op], 0);
    7293. 

  7293. 

  7294. 		} else if (op_num < try_catch->finally_end) {
    7295. 

  7295. 			zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
    7296. 

  7296. 

  7297. 			/* cleanup incomplete RETURN statement */
    7298. 

  7298. 			if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
    7299. 

  7299. 			 && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
    7300. 

  7300. 				zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
    7301. 

  7301. 

  7302. 				zval_ptr_dtor(return_value);
    7303. 

  7303. 			}
    7304. 

  7304. 

  7305. 			/* Chain potential exception from wrapping finally block */
    7306. 

  7306. 			if (Z_OBJ_P(fast_call)) {
    7307. 

  7307. 				if (ex) {
    7308. 

  7308. 					zend_exception_set_previous(ex, Z_OBJ_P(fast_call));
    7309. 

  7309. 				} else {
    7310. 

  7310. 					EG(exception) = Z_OBJ_P(fast_call);
    7311. 

  7311. 				}
    7312. 

  7312. 				ex = Z_OBJ_P(fast_call);
    7313. 

  7313. 			}
    7314. 

  7314. 		}
    7315. 

  7315. 

  7316. 		try_catch_offset--;
    7317. 

  7317. 	}
    7318. 

  7318. 

  7319. 	/* Uncaught exception */
    7320. 

  7320. 	cleanup_live_vars(execute_data, op_num, 0);
    7321. 

  7321. 	if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
    7322. 

  7322. 		zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
    7323. 

  7323. 		zend_generator_close(generator, 1);
    7324. 

  7324. 		ZEND_VM_RETURN();
    7325. 

  7325. 	} else {
    7326. 

  7326. 		/* We didn't execute RETURN, and have to initialize return_value */
    7327. 

  7327. 		if (EX(return_value)) {
    7328. 

  7328. 			ZVAL_UNDEF(EX(return_value));
    7329. 

  7329. 		}
    7330. 

  7330. 		ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
    7331. 

  7331. 	}
    7332. 

  7332. }
    7333. 

  7333. 

  7334. ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
    7335. 

  7335. {
    7336. 

  7336. 	const zend_op *throw_op = EG(opline_before_exception);
    7337. 

  7337. 	uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes;
    7338. 

  7338. 	int i, current_try_catch_offset = -1;
    7339. 

  7339. 

  7340. 	if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE)
    7341. 

  7341. 		&& throw_op->extended_value & ZEND_FREE_ON_RETURN) {
    7342. 

  7342. 		/* exceptions thrown because of loop var destruction on return/break/...
    7343. 

  7343. 		 * are logically thrown at the end of the foreach loop, so adjust the
    7344. 

  7344. 		 * throw_op_num.
    7345. 

  7345. 		 */
    7346. 

  7346. 		const zend_live_range *range = find_live_range(
    7347. 

  7347. 			&EX(func)->op_array, throw_op_num, throw_op->op1.var);
    7348. 

  7348. 		throw_op_num = range->end;
    7349. 

  7349. 	}
    7350. 

  7350. 

  7351. 	/* Find the innermost try/catch/finally the exception was thrown in */
    7352. 

  7352. 	for (i = 0; i < EX(func)->op_array.last_try_catch; i++) {
    7353. 

  7353. 		zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i];
    7354. 

  7354. 		if (try_catch->try_op > throw_op_num) {
    7355. 

  7355. 			/* further blocks will not be relevant... */
    7356. 

  7356. 			break;
    7357. 

  7357. 		}
    7358. 

  7358. 		if (throw_op_num < try_catch->catch_op || throw_op_num < try_catch->finally_end) {
    7359. 

  7359. 			current_try_catch_offset = i;
    7360. 

  7360. 		}
    7361. 

  7361. 	}
    7362. 

  7362. 

  7363. 	cleanup_unfinished_calls(execute_data, throw_op_num);
    7364. 

  7364. 

  7365. 	if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
    7366. 

  7366. 		switch (throw_op->opcode) {
    7367. 

  7367. 			case ZEND_ADD_ARRAY_ELEMENT:
    7368. 

  7368. 			case ZEND_ADD_ARRAY_UNPACK:
    7369. 

  7369. 			case ZEND_ROPE_INIT:
    7370. 

  7370. 			case ZEND_ROPE_ADD:
    7371. 

  7371. 				break; /* exception while building structures, live range handling will free those */
    7372. 

  7372. 

  7373. 			case ZEND_FETCH_CLASS:
    7374. 

  7374. 			case ZEND_DECLARE_ANON_CLASS:
    7375. 

  7375. 				break; /* return value is zend_class_entry pointer */
    7376. 

  7376. 

  7377. 			default:
    7378. 

  7378. 				/* smart branch opcodes may not initialize result */
    7379. 

  7379. 				if (!zend_is_smart_branch(throw_op)) {
    7380. 

  7380. 					zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
    7381. 

  7381. 				}
    7382. 

  7382. 		}
    7383. 

  7383. 	}
    7384. 

  7384. 

  7385. 	ZEND_VM_DISPATCH_TO_HELPER(zend_dispatch_try_catch_finally_helper, try_catch_offset, current_try_catch_offset, op_num, throw_op_num);
    7386. 

  7386. }
    7387. 

  7387. 

  7388. ZEND_VM_HANDLER(150, ZEND_USER_OPCODE, ANY, ANY)
    7389. 

  7389. {
    7390. 

  7390. 	USE_OPLINE
    7391. 

  7391. 	int ret;
    7392. 

  7392. 

  7393. 	SAVE_OPLINE();
    7394. 

  7394. 	ret = zend_user_opcode_handlers[opline->opcode](execute_data);
    7395. 

  7395. 	opline = EX(opline);
    7396. 

  7396. 

  7397. 	switch (ret) {
    7398. 

  7398. 		case ZEND_USER_OPCODE_CONTINUE:
    7399. 

  7399. 			ZEND_VM_CONTINUE();
    7400. 

  7400. 		case ZEND_USER_OPCODE_RETURN:
    7401. 

  7401. 			if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
    7402. 

  7402. 				zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
    7403. 

  7403. 				zend_generator_close(generator, 1);
    7404. 

  7404. 				ZEND_VM_RETURN();
    7405. 

  7405. 			} else {
    7406. 

  7406. 				ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
    7407. 

  7407. 			}
    7408. 

  7408. 		case ZEND_USER_OPCODE_ENTER:
    7409. 

  7409. 			ZEND_VM_ENTER();
    7410. 

  7410. 		case ZEND_USER_OPCODE_LEAVE:
    7411. 

  7411. 			ZEND_VM_LEAVE();
    7412. 

  7412. 		case ZEND_USER_OPCODE_DISPATCH:
    7413. 

  7413. 			ZEND_VM_DISPATCH(opline->opcode, opline);
    7414. 

  7414. 		default:
    7415. 

  7415. 			ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), opline);
    7416. 

  7416. 	}
    7417. 

  7417. }
    7418. 

  7418. 

  7419. ZEND_VM_HANDLER(143, ZEND_DECLARE_CONST, CONST, CONST)
    7420. 

  7420. {
    7421. 

  7421. 	USE_OPLINE
    7422. 

  7422. 	zval *name;
    7423. 

  7423. 	zval *val;
    7424. 

  7424. 	zend_constant c;
    7425. 

  7425. 

  7426. 	SAVE_OPLINE();
    7427. 

  7427. 	name  = GET_OP1_ZVAL_PTR(BP_VAR_R);
    7428. 

  7428. 	val   = GET_OP2_ZVAL_PTR(BP_VAR_R);
    7429. 

  7429. 

  7430. 	ZVAL_COPY(&c.value, val);
    7431. 

  7431. 	if (Z_OPT_CONSTANT(c.value)) {
    7432. 

  7432. 		if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
    7433. 

  7433. 			zval_ptr_dtor_nogc(&c.value);
    7434. 

  7434. 			FREE_OP1();
    7435. 

  7435. 			FREE_OP2();
    7436. 

  7436. 			HANDLE_EXCEPTION();
    7437. 

  7437. 		}
    7438. 

  7438. 	}
    7439. 

  7439. 	/* non persistent, case sensitive */
    7440. 

  7440. 	ZEND_CONSTANT_SET_FLAGS(&c, CONST_CS, PHP_USER_CONSTANT);
    7441. 

  7441. 	c.name = zend_string_copy(Z_STR_P(name));
    7442. 

  7442. 

  7443. 	if (zend_register_constant(&c) == FAILURE) {
    7444. 

  7444. 	}
    7445. 

  7445. 

  7446. 	FREE_OP1();
    7447. 

  7447. 	FREE_OP2();
    7448. 

  7448. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7449. 

  7449. }
    7450. 

  7450. 

  7451. ZEND_VM_HANDLER(142, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, UNUSED, CACHE_SLOT)
    7452. 

  7452. {
    7453. 

  7453. 	USE_OPLINE
    7454. 

  7454. 	zend_function *func;
    7455. 

  7455. 	zval *zfunc;
    7456. 

  7456. 	zval *object;
    7457. 

  7457. 	zend_class_entry *called_scope;
    7458. 

  7458. 

  7459. 	func = CACHED_PTR(opline->extended_value);
    7460. 

  7460. 	if (UNEXPECTED(func == NULL)) {
    7461. 

  7461. 		zfunc = zend_hash_find_ex(EG(function_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)), 1);
    7462. 

  7462. 		ZEND_ASSERT(zfunc != NULL);
    7463. 

  7463. 		func = Z_FUNC_P(zfunc);
    7464. 

  7464. 		ZEND_ASSERT(func->type == ZEND_USER_FUNCTION);
    7465. 

  7465. 		CACHE_PTR(opline->extended_value, func);
    7466. 

  7466. 	}
    7467. 

  7467. 

  7468. 	if (Z_TYPE(EX(This)) == IS_OBJECT) {
    7469. 

  7469. 		called_scope = Z_OBJCE(EX(This));
    7470. 

  7470. 		if (UNEXPECTED((func->common.fn_flags & ZEND_ACC_STATIC) ||
    7471. 

  7471. 				(EX(func)->common.fn_flags & ZEND_ACC_STATIC))) {
    7472. 

  7472. 			object = NULL;
    7473. 

  7473. 		} else {
    7474. 

  7474. 			object = &EX(This);
    7475. 

  7475. 		}
    7476. 

  7476. 	} else {
    7477. 

  7477. 		called_scope = Z_CE(EX(This));
    7478. 

  7478. 		object = NULL;
    7479. 

  7479. 	}
    7480. 

  7480. 	zend_create_closure(EX_VAR(opline->result.var), func,
    7481. 

  7481. 		EX(func)->op_array.scope, called_scope, object);
    7482. 

  7482. 

  7483. 	ZEND_VM_NEXT_OPCODE();
    7484. 

  7484. }
    7485. 

  7485. 

  7486. ZEND_VM_HANDLER(156, ZEND_SEPARATE, VAR, UNUSED)
    7487. 

  7487. {
    7488. 

  7488. 	USE_OPLINE
    7489. 

  7489. 	zval *var_ptr;
    7490. 

  7490. 

  7491. 	var_ptr = EX_VAR(opline->op1.var);
    7492. 

  7492. 	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
    7493. 

  7493. 		if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) {
    7494. 

  7494. 			ZVAL_UNREF(var_ptr);
    7495. 

  7495. 		}
    7496. 

  7496. 	}
    7497. 

  7497. 

  7498. 	ZEND_VM_NEXT_OPCODE();
    7499. 

  7499. }
    7500. 

  7500. 

  7501. ZEND_VM_COLD_HELPER(zend_yield_in_closed_generator_helper, ANY, ANY)
    7502. 

  7502. {
    7503. 

  7503. 	USE_OPLINE
    7504. 

  7504. 

  7505. 	SAVE_OPLINE();
    7506. 

  7506. 	zend_throw_error(NULL, "Cannot yield from finally in a force-closed generator");
    7507. 

  7507. 	FREE_UNFETCHED_OP2();
    7508. 

  7508. 	FREE_UNFETCHED_OP1();
    7509. 

  7509. 	UNDEF_RESULT();
    7510. 

  7510. 	HANDLE_EXCEPTION();
    7511. 

  7511. }
    7512. 

  7512. 

  7513. ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMPVAR|CV|UNUSED, SRC)
    7514. 

  7514. {
    7515. 

  7515. 	USE_OPLINE
    7516. 

  7516. 

  7517. 	zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
    7518. 

  7518. 

  7519. 	SAVE_OPLINE();
    7520. 

  7520. 	if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
    7521. 

  7521. 		ZEND_VM_DISPATCH_TO_HELPER(zend_yield_in_closed_generator_helper);
    7522. 

  7522. 	}
    7523. 

  7523. 

  7524. 	/* Destroy the previously yielded value */
    7525. 

  7525. 	zval_ptr_dtor(&generator->value);
    7526. 

  7526. 

  7527. 	/* Destroy the previously yielded key */
    7528. 

  7528. 	zval_ptr_dtor(&generator->key);
    7529. 

  7529. 

  7530. 	/* Set the new yielded value */
    7531. 

  7531. 	if (OP1_TYPE != IS_UNUSED) {
    7532. 

  7532. 		if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
    7533. 

  7533. 			/* Constants and temporary variables aren't yieldable by reference,
    7534. 

  7534. 			 * but we still allow them with a notice. */
    7535. 

  7535. 			if (OP1_TYPE & (IS_CONST|IS_TMP_VAR)) {
    7536. 

  7536. 				zval *value;
    7537. 

  7537. 

  7538. 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
    7539. 

  7539. 

  7540. 				value = GET_OP1_ZVAL_PTR(BP_VAR_R);
    7541. 

  7541. 				ZVAL_COPY_VALUE(&generator->value, value);
    7542. 

  7542. 				if (OP1_TYPE == IS_CONST) {
    7543. 

  7543. 					if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
    7544. 

  7544. 						Z_ADDREF(generator->value);
    7545. 

  7545. 					}
    7546. 

  7546. 				}
    7547. 

  7547. 			} else {
    7548. 

  7548. 				zval *value_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
    7549. 

  7549. 

  7550. 				/* If a function call result is yielded and the function did
    7551. 

  7551. 				 * not return by reference we throw a notice. */
    7552. 

  7552. 				do {
    7553. 

  7553. 					if (OP1_TYPE == IS_VAR) {
    7554. 

  7554. 						ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
    7555. 

  7555. 						if (opline->extended_value == ZEND_RETURNS_FUNCTION
    7556. 

  7556. 						 && !Z_ISREF_P(value_ptr)) {
    7557. 

  7557. 							zend_error(E_NOTICE, "Only variable references should be yielded by reference");
    7558. 

  7558. 							ZVAL_COPY(&generator->value, value_ptr);
    7559. 

  7559. 							break;
    7560. 

  7560. 						}
    7561. 

  7561. 					}
    7562. 

  7562. 					if (Z_ISREF_P(value_ptr)) {
    7563. 

  7563. 						Z_ADDREF_P(value_ptr);
    7564. 

  7564. 					} else {
    7565. 

  7565. 						ZVAL_MAKE_REF_EX(value_ptr, 2);
    7566. 

  7566. 					}
    7567. 

  7567. 					ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
    7568. 

  7568. 				} while (0);
    7569. 

  7569. 

  7570. 				FREE_OP1_VAR_PTR();
    7571. 

  7571. 			}
    7572. 

  7572. 		} else {
    7573. 

  7573. 			zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
    7574. 

  7574. 

  7575. 			/* Consts, temporary variables and references need copying */
    7576. 

  7576. 			if (OP1_TYPE == IS_CONST) {
    7577. 

  7577. 				ZVAL_COPY_VALUE(&generator->value, value);
    7578. 

  7578. 				if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
    7579. 

  7579. 					Z_ADDREF(generator->value);
    7580. 

  7580. 				}
    7581. 

  7581. 			} else if (OP1_TYPE == IS_TMP_VAR) {
    7582. 

  7582. 				ZVAL_COPY_VALUE(&generator->value, value);
    7583. 

  7583.             } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
    7584. 

  7584. 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
    7585. 

  7585. 				FREE_OP1_IF_VAR();
    7586. 

  7586. 			} else {
    7587. 

  7587. 				ZVAL_COPY_VALUE(&generator->value, value);
    7588. 

  7588. 				if (OP1_TYPE == IS_CV) {
    7589. 

  7589. 					if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
    7590. 

  7590. 				}
    7591. 

  7591. 			}
    7592. 

  7592. 		}
    7593. 

  7593. 	} else {
    7594. 

  7594. 		/* If no value was specified yield null */
    7595. 

  7595. 		ZVAL_NULL(&generator->value);
    7596. 

  7596. 	}
    7597. 

  7597. 

  7598. 	/* Set the new yielded key */
    7599. 

  7599. 	if (OP2_TYPE != IS_UNUSED) {
    7600. 

  7600. 		zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
    7601. 

  7601. 		if ((OP2_TYPE & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key)) == IS_REFERENCE) {
    7602. 

  7602. 			key = Z_REFVAL_P(key);
    7603. 

  7603. 		}
    7604. 

  7604. 		ZVAL_COPY(&generator->key, key);
    7605. 

  7605. 		FREE_OP2();
    7606. 

  7606. 

  7607. 		if (Z_TYPE(generator->key) == IS_LONG
    7608. 

  7608. 		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
    7609. 

  7609. 		) {
    7610. 

  7610. 			generator->largest_used_integer_key = Z_LVAL(generator->key);
    7611. 

  7611. 		}
    7612. 

  7612. 	} else {
    7613. 

  7613. 		/* If no key was specified we use auto-increment keys */
    7614. 

  7614. 		generator->largest_used_integer_key++;
    7615. 

  7615. 		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
    7616. 

  7616. 	}
    7617. 

  7617. 

  7618. 	if (RETURN_VALUE_USED(opline)) {
    7619. 

  7619. 		/* If the return value of yield is used set the send
    7620. 

  7620. 		 * target and initialize it to NULL */
    7621. 

  7621. 		generator->send_target = EX_VAR(opline->result.var);
    7622. 

  7622. 		ZVAL_NULL(generator->send_target);
    7623. 

  7623. 	} else {
    7624. 

  7624. 		generator->send_target = NULL;
    7625. 

  7625. 	}
    7626. 

  7626. 

  7627. 	/* We increment to the next op, so we are at the correct position when the
    7628. 

  7628. 	 * generator is resumed. */
    7629. 

  7629. 	ZEND_VM_INC_OPCODE();
    7630. 

  7630. 

  7631. 	/* The GOTO VM uses a local opline variable. We need to set the opline
    7632. 

  7632. 	 * variable in execute_data so we don't resume at an old position. */
    7633. 

  7633. 	SAVE_OPLINE();
    7634. 

  7634. 

  7635. 	ZEND_VM_RETURN();
    7636. 

  7636. }
    7637. 

  7637. 

  7638. ZEND_VM_HANDLER(166, ZEND_YIELD_FROM, CONST|TMPVAR|CV, ANY)
    7639. 

  7639. {
    7640. 

  7640. 	USE_OPLINE
    7641. 

  7641. 	zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
    7642. 

  7642. 	zval *val;
    7643. 

  7643. 

  7644. 	SAVE_OPLINE();
    7645. 

  7645. 	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
    7646. 

  7646. 

  7647. 	if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
    7648. 

  7648. 		zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
    7649. 

  7649. 		FREE_OP1();
    7650. 

  7650. 		UNDEF_RESULT();
    7651. 

  7651. 		HANDLE_EXCEPTION();
    7652. 

  7652. 	}
    7653. 

  7653. 

  7654. ZEND_VM_C_LABEL(yield_from_try_again):
    7655. 

  7655. 	if (Z_TYPE_P(val) == IS_ARRAY) {
    7656. 

  7656. 		ZVAL_COPY_VALUE(&generator->values, val);
    7657. 

  7657. 		if (Z_OPT_REFCOUNTED_P(val)) {
    7658. 

  7658. 			Z_ADDREF_P(val);
    7659. 

  7659. 		}
    7660. 

  7660. 		Z_FE_POS(generator->values) = 0;
    7661. 

  7661. 		FREE_OP1();
    7662. 

  7662. 	} else if (OP1_TYPE != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
    7663. 

  7663. 		zend_class_entry *ce = Z_OBJCE_P(val);
    7664. 

  7664. 		if (ce == zend_ce_generator) {
    7665. 

  7665. 			zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
    7666. 

  7666. 

  7667. 			Z_ADDREF_P(val);
    7668. 

  7668. 			FREE_OP1();
    7669. 

  7669. 

  7670. 			if (Z_ISUNDEF(new_gen->retval)) {
    7671. 

  7671. 				if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
    7672. 

  7672. 					zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
    7673. 

  7673. 					zval_ptr_dtor(val);
    7674. 

  7674. 					UNDEF_RESULT();
    7675. 

  7675. 					HANDLE_EXCEPTION();
    7676. 

  7676. 				} else {
    7677. 

  7677. 					zend_generator_yield_from(generator, new_gen);
    7678. 

  7678. 				}
    7679. 

  7679. 			} else if (UNEXPECTED(new_gen->execute_data == NULL)) {
    7680. 

  7680. 				zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
    7681. 

  7681. 				zval_ptr_dtor(val);
    7682. 

  7682. 				UNDEF_RESULT();
    7683. 

  7683. 				HANDLE_EXCEPTION();
    7684. 

  7684. 			} else {
    7685. 

  7685. 				if (RETURN_VALUE_USED(opline)) {
    7686. 

  7686. 					ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
    7687. 

  7687. 				}
    7688. 

  7688. 				ZEND_VM_NEXT_OPCODE();
    7689. 

  7689. 			}
    7690. 

  7690. 		} else {
    7691. 

  7691. 			zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
    7692. 

  7692. 			FREE_OP1();
    7693. 

  7693. 

  7694. 			if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
    7695. 

  7695. 				if (!EG(exception)) {
    7696. 

  7696. 					zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
    7697. 

  7697. 				}
    7698. 

  7698. 				UNDEF_RESULT();
    7699. 

  7699. 				HANDLE_EXCEPTION();
    7700. 

  7700. 			}
    7701. 

  7701. 

  7702. 			iter->index = 0;
    7703. 

  7703. 			if (iter->funcs->rewind) {
    7704. 

  7704. 				iter->funcs->rewind(iter);
    7705. 

  7705. 				if (UNEXPECTED(EG(exception) != NULL)) {
    7706. 

  7706. 					OBJ_RELEASE(&iter->std);
    7707. 

  7707. 					UNDEF_RESULT();
    7708. 

  7708. 					HANDLE_EXCEPTION();
    7709. 

  7709. 				}
    7710. 

  7710. 			}
    7711. 

  7711. 

  7712. 			ZVAL_OBJ(&generator->values, &iter->std);
    7713. 

  7713. 		}
    7714. 

  7714. 	} else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
    7715. 

  7715. 		val = Z_REFVAL_P(val);
    7716. 

  7716. 		ZEND_VM_C_GOTO(yield_from_try_again);
    7717. 

  7717. 	} else {
    7718. 

  7718. 		zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
    7719. 

  7719. 		UNDEF_RESULT();
    7720. 

  7720. 		HANDLE_EXCEPTION();
    7721. 

  7721. 	}
    7722. 

  7722. 

  7723. 	/* This is the default return value
    7724. 

  7724. 	 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
    7725. 

  7725. 	if (RETURN_VALUE_USED(opline)) {
    7726. 

  7726. 		ZVAL_NULL(EX_VAR(opline->result.var));
    7727. 

  7727. 	}
    7728. 

  7728. 

  7729. 	/* This generator has no send target (though the generator we delegate to might have one) */
    7730. 

  7730. 	generator->send_target = NULL;
    7731. 

  7731. 

  7732. 	/* We increment to the next op, so we are at the correct position when the
    7733. 

  7733. 	 * generator is resumed. */
    7734. 

  7734. 	ZEND_VM_INC_OPCODE();
    7735. 

  7735. 

  7736. 	/* The GOTO VM uses a local opline variable. We need to set the opline
    7737. 

  7737. 	 * variable in execute_data so we don't resume at an old position. */
    7738. 

  7738. 	SAVE_OPLINE();
    7739. 

  7739. 

  7740. 	ZEND_VM_RETURN();
    7741. 

  7741. }
    7742. 

  7742. 

  7743. ZEND_VM_HANDLER(159, ZEND_DISCARD_EXCEPTION, ANY, ANY)
    7744. 

  7744. {
    7745. 

  7745. 	USE_OPLINE
    7746. 

  7746. 	zval *fast_call = EX_VAR(opline->op1.var);
    7747. 

  7747. 	SAVE_OPLINE();
    7748. 

  7748. 

  7749. 	/* cleanup incomplete RETURN statement */
    7750. 

  7750. 	if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
    7751. 

  7751. 	 && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
    7752. 

  7752. 		zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
    7753. 

  7753. 

  7754. 		zval_ptr_dtor(return_value);
    7755. 

  7755. 	}
    7756. 

  7756. 

  7757. 	/* cleanup delayed exception */
    7758. 

  7758. 	if (Z_OBJ_P(fast_call) != NULL) {
    7759. 

  7759. 		/* discard the previously thrown exception */
    7760. 

  7760. 		OBJ_RELEASE(Z_OBJ_P(fast_call));
    7761. 

  7761. 		Z_OBJ_P(fast_call) = NULL;
    7762. 

  7762. 	}
    7763. 

  7763. 

  7764. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7765. 

  7765. }
    7766. 

  7766. 

  7767. ZEND_VM_HANDLER(162, ZEND_FAST_CALL, JMP_ADDR, ANY)
    7768. 

  7768. {
    7769. 

  7769. 	USE_OPLINE
    7770. 

  7770. 	zval *fast_call = EX_VAR(opline->result.var);
    7771. 

  7771. 

  7772. 	Z_OBJ_P(fast_call) = NULL;
    7773. 

  7773. 	/* set return address */
    7774. 

  7774. 	Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.opcodes;
    7775. 

  7775. 	ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
    7776. 

  7776. }
    7777. 

  7777. 

  7778. ZEND_VM_HANDLER(163, ZEND_FAST_RET, ANY, TRY_CATCH)
    7779. 

  7779. {
    7780. 

  7780. 	USE_OPLINE
    7781. 

  7781. 	zval *fast_call = EX_VAR(opline->op1.var);
    7782. 

  7782. 	uint32_t current_try_catch_offset, current_op_num;
    7783. 

  7783. 

  7784. 	if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1) {
    7785. 

  7785. 		const zend_op *fast_ret = EX(func)->op_array.opcodes + Z_OPLINE_NUM_P(fast_call);
    7786. 

  7786. 

  7787. 		ZEND_VM_JMP_EX(fast_ret + 1, 0);
    7788. 

  7788. 	}
    7789. 

  7789. 

  7790. 	/* special case for unhandled exceptions */
    7791. 

  7791. 	EG(exception) = Z_OBJ_P(fast_call);
    7792. 

  7792. 	Z_OBJ_P(fast_call) = NULL;
    7793. 

  7793. 	current_try_catch_offset = opline->op2.num;
    7794. 

  7794. 	current_op_num = opline - EX(func)->op_array.opcodes;
    7795. 

  7795. 	ZEND_VM_DISPATCH_TO_HELPER(zend_dispatch_try_catch_finally_helper, try_catch_offset, current_try_catch_offset, op_num, current_op_num);
    7796. 

  7796. }
    7797. 

  7797. 

  7798. ZEND_VM_HOT_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST, CACHE_SLOT)
    7799. 

  7799. {
    7800. 

  7800. 	USE_OPLINE
    7801. 

  7801. 	zend_string *varname;
    7802. 

  7802. 	zval *value;
    7803. 

  7803. 	zval *variable_ptr;
    7804. 

  7804. 	uintptr_t idx;
    7805. 

  7805. 	zend_reference *ref;
    7806. 

  7806. 

  7807. 	ZEND_VM_REPEATABLE_OPCODE
    7808. 

  7808. 

  7809. 	varname = Z_STR_P(GET_OP2_ZVAL_PTR(BP_VAR_R));
    7810. 

  7810. 

  7811. 	/* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
    7812. 

  7812. 	idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
    7813. 

  7813. 	if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
    7814. 

  7814. 		Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
    7815. 

  7815. 

  7816. 		if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
    7817. 

  7817. 	        (EXPECTED(p->key == varname) ||
    7818. 

  7818. 	         (EXPECTED(p->h == ZSTR_H(varname)) &&
    7819. 

  7819. 	          EXPECTED(p->key != NULL) &&
    7820. 

  7820. 	          EXPECTED(zend_string_equal_content(p->key, varname))))) {
    7821. 

  7821. 

  7822. 			value = (zval*)p; /* value = &p->val; */
    7823. 

  7823. 			ZEND_VM_C_GOTO(check_indirect);
    7824. 

  7824. 		}
    7825. 

  7825. 	}
    7826. 

  7826. 

  7827. 	value = zend_hash_find_ex(&EG(symbol_table), varname, 1);
    7828. 

  7828. 	if (UNEXPECTED(value == NULL)) {
    7829. 

  7829. 		value = zend_hash_add_new(&EG(symbol_table), varname, &EG(uninitialized_zval));
    7830. 

  7830. 		idx = (char*)value - (char*)EG(symbol_table).arData;
    7831. 

  7831. 		/* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
    7832. 

  7832. 		CACHE_PTR(opline->extended_value, (void*)(idx + 1));
    7833. 

  7833. 	} else {
    7834. 

  7834. 		idx = (char*)value - (char*)EG(symbol_table).arData;
    7835. 

  7835. 		/* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
    7836. 

  7836. 		CACHE_PTR(opline->extended_value, (void*)(idx + 1));
    7837. 

  7837. ZEND_VM_C_LABEL(check_indirect):
    7838. 

  7838. 		/* GLOBAL variable may be an INDIRECT pointer to CV */
    7839. 

  7839. 		if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
    7840. 

  7840. 			value = Z_INDIRECT_P(value);
    7841. 

  7841. 			if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
    7842. 

  7842. 				ZVAL_NULL(value);
    7843. 

  7843. 			}
    7844. 

  7844. 		}
    7845. 

  7845. 	}
    7846. 

  7846. 

  7847. 	if (UNEXPECTED(!Z_ISREF_P(value))) {
    7848. 

  7848. 		ZVAL_MAKE_REF_EX(value, 2);
    7849. 

  7849. 		ref = Z_REF_P(value);
    7850. 

  7850. 	} else {
    7851. 

  7851. 		ref = Z_REF_P(value);
    7852. 

  7852. 		GC_ADDREF(ref);
    7853. 

  7853. 	}
    7854. 

  7854. 

  7855. 	variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    7856. 

  7856. 

  7857. 	if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
    7858. 

  7858. 		zend_refcounted *garbage = Z_COUNTED_P(variable_ptr);
    7859. 

  7859. 

  7860. 		ZVAL_REF(variable_ptr, ref);
    7861. 

  7861. 		if (GC_DELREF(garbage) == 0) {
    7862. 

  7862. 			SAVE_OPLINE();
    7863. 

  7863. 			rc_dtor_func(garbage);
    7864. 

  7864. 			if (UNEXPECTED(EG(exception))) {
    7865. 

  7865. 				ZVAL_NULL(variable_ptr);
    7866. 

  7866. 				HANDLE_EXCEPTION();
    7867. 

  7867. 			}
    7868. 

  7868. 		} else {
    7869. 

  7869. 			gc_check_possible_root(garbage);
    7870. 

  7870. 		}
    7871. 

  7871. 	} else {
    7872. 

  7872. 		ZVAL_REF(variable_ptr, ref);
    7873. 

  7873. 	}
    7874. 

  7874. 

  7875. 	ZEND_VM_REPEAT_OPCODE(ZEND_BIND_GLOBAL);
    7876. 

  7876. 	ZEND_VM_NEXT_OPCODE();
    7877. 

  7877. }
    7878. 

  7878. 

  7879. ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY)
    7880. 

  7880. {
    7881. 

  7881. 	USE_OPLINE
    7882. 

  7882. 	zval *value;
    7883. 

  7883. 

  7884. 	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    7885. 

  7885. 	if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
    7886. 

  7886. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
    7887. 

  7887. 		FREE_OP1();
    7888. 

  7888. 		ZEND_VM_NEXT_OPCODE();
    7889. 

  7889. 	} else {
    7890. 

  7890. 		zend_bool strict;
    7891. 

  7891. 

  7892. 		if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
    7893. 

  7893. 			value = Z_REFVAL_P(value);
    7894. 

  7894. 			if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
    7895. 

  7895. 				ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
    7896. 

  7896. 				FREE_OP1();
    7897. 

  7897. 				ZEND_VM_NEXT_OPCODE();
    7898. 

  7898. 			}
    7899. 

  7899. 		}
    7900. 

  7900. 

  7901. 		SAVE_OPLINE();
    7902. 

  7902. 		if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
    7903. 

  7903. 			value = ZVAL_UNDEFINED_OP1();
    7904. 

  7904. 		}
    7905. 

  7905. 		strict = EX_USES_STRICT_TYPES();
    7906. 

  7906. 		do {
    7907. 

  7907. 			if (EXPECTED(!strict)) {
    7908. 

  7908. 				zend_string *str;
    7909. 

  7909. 				zval tmp;
    7910. 

  7910. 

  7911. 				ZVAL_COPY(&tmp, value);
    7912. 

  7912. 				if (zend_parse_arg_str_weak(&tmp, &str)) {
    7913. 

  7913. 					ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
    7914. 

  7914. 					zval_ptr_dtor(&tmp);
    7915. 

  7915. 					break;
    7916. 

  7916. 				}
    7917. 

  7917. 				zval_ptr_dtor(&tmp);
    7918. 

  7918. 			}
    7919. 

  7919. 			if (!EG(exception)) {
    7920. 

  7920. 				zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
    7921. 

  7921. 			}
    7922. 

  7922. 			ZVAL_UNDEF(EX_VAR(opline->result.var));
    7923. 

  7923. 		} while (0);
    7924. 

  7924. 	}
    7925. 

  7925. 	FREE_OP1();
    7926. 

  7926. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    7927. 

  7927. }
    7928. 

  7928. 

  7929. ZEND_VM_HOT_NOCONST_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMPVAR|CV, ANY, TYPE_MASK)
    7930. 

  7930. {
    7931. 

  7931. 	USE_OPLINE
    7932. 

  7932. 	zval *value;
    7933. 

  7933. 	int result = 0;
    7934. 

  7934. 

  7935. 	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    7936. 

  7936. 	if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
    7937. 

  7937. ZEND_VM_C_LABEL(type_check_resource):
    7938. 

  7938. 		if (opline->extended_value != MAY_BE_RESOURCE
    7939. 

  7939. 		 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
    7940. 

  7940. 			result = 1;
    7941. 

  7941. 		}
    7942. 

  7942. 	} else if ((OP1_TYPE & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
    7943. 

  7943. 		value = Z_REFVAL_P(value);
    7944. 

  7944. 		if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
    7945. 

  7945. 			ZEND_VM_C_GOTO(type_check_resource);
    7946. 

  7946. 		}
    7947. 

  7947. 	} else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
    7948. 

  7948. 		result = ((1 << IS_NULL) & opline->extended_value) != 0;
    7949. 

  7949. 		SAVE_OPLINE();
    7950. 

  7950. 		ZVAL_UNDEFINED_OP1();
    7951. 

  7951. 		if (UNEXPECTED(EG(exception))) {
    7952. 

  7952. 			ZVAL_UNDEF(EX_VAR(opline->result.var));
    7953. 

  7953. 			HANDLE_EXCEPTION();
    7954. 

  7954. 		}
    7955. 

  7955. 	}
    7956. 

  7956. 	if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    7957. 

  7957. 		SAVE_OPLINE();
    7958. 

  7958. 		FREE_OP1();
    7959. 

  7959. 		ZEND_VM_SMART_BRANCH(result, 1);
    7960. 

  7960. 	} else {
    7961. 

  7961. 		ZEND_VM_SMART_BRANCH(result, 0);
    7962. 

  7962. 	}
    7963. 

  7963. }
    7964. 

  7964. 

  7965. ZEND_VM_HOT_HANDLER(122, ZEND_DEFINED, CONST, ANY, CACHE_SLOT)
    7966. 

  7966. {
    7967. 

  7967. 	USE_OPLINE
    7968. 

  7968. 	zend_constant *c;
    7969. 

  7969. 

  7970. 	c = CACHED_PTR(opline->extended_value);
    7971. 

  7971. 	if (EXPECTED(c != NULL)) {
    7972. 

  7972. 		if (!IS_SPECIAL_CACHE_VAL(c)) {
    7973. 

  7973. ZEND_VM_C_LABEL(defined_true):
    7974. 

  7974. 			ZEND_VM_SMART_BRANCH_TRUE();
    7975. 

  7975. 		} else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
    7976. 

  7976. ZEND_VM_C_LABEL(defined_false):
    7977. 

  7977. 			ZEND_VM_SMART_BRANCH_FALSE();
    7978. 

  7978. 		}
    7979. 

  7979. 	}
    7980. 

  7980. 	if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
    7981. 

  7981. 		CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
    7982. 

  7982. 		ZEND_VM_C_GOTO(defined_false);
    7983. 

  7983. 	} else {
    7984. 

  7984. 		ZEND_VM_C_GOTO(defined_true);
    7985. 

  7985. 	}
    7986. 

  7986. }
    7987. 

  7987. 

  7988. ZEND_VM_HANDLER(151, ZEND_ASSERT_CHECK, ANY, JMP_ADDR)
    7989. 

  7989. {
    7990. 

  7990. 	USE_OPLINE
    7991. 

  7991. 

  7992. 	if (EG(assertions) <= 0) {
    7993. 

  7993. 		zend_op *target = OP_JMP_ADDR(opline, opline->op2);
    7994. 

  7994. 		if (RETURN_VALUE_USED(opline)) {
    7995. 

  7995. 			ZVAL_TRUE(EX_VAR(opline->result.var));
    7996. 

  7996. 		}
    7997. 

  7997. 		ZEND_VM_JMP_EX(target, 0);
    7998. 

  7998. 	} else {
    7999. 

  7999. 		ZEND_VM_NEXT_OPCODE();
    8000. 

  8000. 	}
    8001. 

  8001. }
    8002. 

  8002. 

  8003. ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, CV|TMPVAR|UNUSED|CLASS_FETCH, ANY)
    8004. 

  8004. {
    8005. 

  8005. 	uint32_t fetch_type;
    8006. 

  8006. 	zend_class_entry *called_scope, *scope;
    8007. 

  8007. 	USE_OPLINE
    8008. 

  8008. 

  8009. 	if (OP1_TYPE != IS_UNUSED) {
    8010. 

  8010. 		zval *op = GET_OP1_ZVAL_PTR(BP_VAR_R);
    8011. 

  8011. 		SAVE_OPLINE();
    8012. 

  8012. 		if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
    8013. 

  8013. 			ZVAL_DEREF(op);
    8014. 

  8014. 			if (Z_TYPE_P(op) != IS_OBJECT) {
    8015. 

  8015. 				zend_type_error("Cannot use ::class on value of type %s",
    8016. 

  8016. 					zend_get_type_by_const(Z_TYPE_P(op)));
    8017. 

  8017. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    8018. 

  8018. 				FREE_OP1();
    8019. 

  8019. 				HANDLE_EXCEPTION();
    8020. 

  8020. 			}
    8021. 

  8021. 		}
    8022. 

  8022. 

  8023. 		ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
    8024. 

  8024. 		FREE_OP1();
    8025. 

  8025. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    8026. 

  8026. 	}
    8027. 

  8027. 

  8028. 	fetch_type = opline->op1.num;
    8029. 

  8029. 	scope = EX(func)->op_array.scope;
    8030. 

  8030. 	if (UNEXPECTED(scope == NULL)) {
    8031. 

  8031. 		SAVE_OPLINE();
    8032. 

  8032. 		zend_throw_error(NULL, "Cannot use \"%s\" when no class scope is active",
    8033. 

  8033. 			fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
    8034. 

  8034. 			fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
    8035. 

  8035. 		ZVAL_UNDEF(EX_VAR(opline->result.var));
    8036. 

  8036. 		HANDLE_EXCEPTION();
    8037. 

  8037. 	}
    8038. 

  8038. 

  8039. 	switch (fetch_type) {
    8040. 

  8040. 		case ZEND_FETCH_CLASS_SELF:
    8041. 

  8041. 			ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
    8042. 

  8042. 			break;
    8043. 

  8043. 		case ZEND_FETCH_CLASS_PARENT:
    8044. 

  8044. 			if (UNEXPECTED(scope->parent == NULL)) {
    8045. 

  8045. 				SAVE_OPLINE();
    8046. 

  8046. 				zend_throw_error(NULL,
    8047. 

  8047. 					"Cannot use \"parent\" when current class scope has no parent");
    8048. 

  8048. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    8049. 

  8049. 				HANDLE_EXCEPTION();
    8050. 

  8050. 			}
    8051. 

  8051. 			ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
    8052. 

  8052. 			break;
    8053. 

  8053. 		case ZEND_FETCH_CLASS_STATIC:
    8054. 

  8054. 			if (Z_TYPE(EX(This)) == IS_OBJECT) {
    8055. 

  8055. 				called_scope = Z_OBJCE(EX(This));
    8056. 

  8056. 			} else {
    8057. 

  8057. 				called_scope = Z_CE(EX(This));
    8058. 

  8058. 			}
    8059. 

  8059. 			ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
    8060. 

  8060. 			break;
    8061. 

  8061. 		EMPTY_SWITCH_DEFAULT_CASE()
    8062. 

  8062. 	}
    8063. 

  8063. 	ZEND_VM_NEXT_OPCODE();
    8064. 

  8064. }
    8065. 

  8065. 

  8066. ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY)
    8067. 

  8067. {
    8068. 

  8068. 	zend_array *args = NULL;
    8069. 

  8069. 	zend_function *fbc = EX(func);
    8070. 

  8070. 	zval *ret = EX(return_value);
    8071. 

  8071. 	uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS);
    8072. 

  8072. 	uint32_t num_args = EX_NUM_ARGS();
    8073. 

  8073. 	zend_execute_data *call;
    8074. 

  8074. 

  8075. 	SAVE_OPLINE();
    8076. 

  8076. 

  8077. 	if (num_args) {
    8078. 

  8078. 		zval *p = ZEND_CALL_ARG(execute_data, 1);
    8079. 

  8079. 		zval *end = p + num_args;
    8080. 

  8080. 

  8081. 		args = zend_new_array(num_args);
    8082. 

  8082. 		zend_hash_real_init_packed(args);
    8083. 

  8083. 		ZEND_HASH_FILL_PACKED(args) {
    8084. 

  8084. 			do {
    8085. 

  8085. 				ZEND_HASH_FILL_ADD(p);
    8086. 

  8086. 				p++;
    8087. 

  8087. 			} while (p != end);
    8088. 

  8088. 		} ZEND_HASH_FILL_END();
    8089. 

  8089. 	}
    8090. 

  8090. 

  8091. 	call = execute_data;
    8092. 

  8092. 	execute_data = EG(current_execute_data) = EX(prev_execute_data);
    8093. 

  8093. 

  8094. 	call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
    8095. 

  8095. 	ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
    8096. 

  8096. 	ZEND_CALL_NUM_ARGS(call) = 2;
    8097. 

  8097. 

  8098. 	ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
    8099. 

  8099. 	if (args) {
    8100. 

  8100. 		ZVAL_ARR(ZEND_CALL_ARG(call, 2), args);
    8101. 

  8101. 	} else {
    8102. 

  8102. 		ZVAL_EMPTY_ARRAY(ZEND_CALL_ARG(call, 2));
    8103. 

  8103. 	}
    8104. 

  8104. 	zend_free_trampoline(fbc);
    8105. 

  8105. 	fbc = call->func;
    8106. 

  8106. 

  8107. 	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
    8108. 

  8108. 		if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
    8109. 

  8109. 			init_func_run_time_cache(&fbc->op_array);
    8110. 

  8110. 		}
    8111. 

  8111. 		execute_data = call;
    8112. 

  8112. 		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
    8113. 

  8113. 		if (EXPECTED(zend_execute_ex == execute_ex)) {
    8114. 

  8114. 			LOAD_OPLINE_EX();
    8115. 

  8115. 			ZEND_VM_ENTER_EX();
    8116. 

  8116. 		} else {
    8117. 

  8117. 			SAVE_OPLINE_EX();
    8118. 

  8118. 			execute_data = EX(prev_execute_data);
    8119. 

  8119. 			LOAD_OPLINE();
    8120. 

  8120. 			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
    8121. 

  8121. 			zend_execute_ex(call);
    8122. 

  8122. 		}
    8123. 

  8123. 	} else {
    8124. 

  8124. 		zval retval;
    8125. 

  8125. 

  8126. 		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
    8127. 

  8127. 

  8128. 		EG(current_execute_data) = call;
    8129. 

  8129. 

  8130. #if ZEND_DEBUG
    8131. 

  8131. 		zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
    8132. 

  8132. #endif
    8133. 

  8133. 

  8134. 		if (ret == NULL) {
    8135. 

  8135. 			ret = &retval;
    8136. 

  8136. 		}
    8137. 

  8137. 

  8138. 		ZVAL_NULL(ret);
    8139. 

  8139. 		if (!zend_execute_internal) {
    8140. 

  8140. 			/* saves one function call if zend_execute_internal is not used */
    8141. 

  8141. 			fbc->internal_function.handler(call, ret);
    8142. 

  8142. 		} else {
    8143. 

  8143. 			zend_execute_internal(call, ret);
    8144. 

  8144. 		}
    8145. 

  8145. 

  8146. #if ZEND_DEBUG
    8147. 

  8147. 		if (!EG(exception) && call->func) {
    8148. 

  8148. 			if (should_throw) {
    8149. 

  8149. 				zend_internal_call_arginfo_violation(call->func);
    8150. 

  8150. 			}
    8151. 

  8151. 			ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
    8152. 

  8152. 				zend_verify_internal_return_type(call->func, ret));
    8153. 

  8153. 			ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
    8154. 

  8154. 				? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
    8155. 

  8155. 		}
    8156. 

  8156. #endif
    8157. 

  8157. 

  8158. 		EG(current_execute_data) = call->prev_execute_data;
    8159. 

  8159. 

  8160. 		zend_vm_stack_free_args(call);
    8161. 

  8161. 		if (ret == &retval) {
    8162. 

  8162. 			zval_ptr_dtor(ret);
    8163. 

  8163. 		}
    8164. 

  8164. 	}
    8165. 

  8165. 

  8166. 	execute_data = EG(current_execute_data);
    8167. 

  8167. 

  8168. 	if (!EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
    8169. 

  8169. 		ZEND_VM_RETURN();
    8170. 

  8170. 	}
    8171. 

  8171. 

  8172. 	if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
    8173. 

  8173. 		zend_object *object = Z_OBJ(call->This);
    8174. 

  8174. 		OBJ_RELEASE(object);
    8175. 

  8175. 	}
    8176. 

  8176. 	zend_vm_stack_free_call_frame(call);
    8177. 

  8177. 

  8178. 	if (UNEXPECTED(EG(exception) != NULL)) {
    8179. 

  8179. 		zend_rethrow_exception(execute_data);
    8180. 

  8180. 		HANDLE_EXCEPTION_LEAVE();
    8181. 

  8181. 	}
    8182. 

  8182. 

  8183. 	LOAD_OPLINE();
    8184. 

  8184. 	ZEND_VM_INC_OPCODE();
    8185. 

  8185. 	ZEND_VM_LEAVE();
    8186. 

  8186. }
    8187. 

  8187. 

  8188. ZEND_VM_HANDLER(182, ZEND_BIND_LEXICAL, TMP, CV, REF)
    8189. 

  8189. {
    8190. 

  8190. 	USE_OPLINE
    8191. 

  8191. 	zval *closure, *var;
    8192. 

  8192. 

  8193. 	closure = GET_OP1_ZVAL_PTR(BP_VAR_R);
    8194. 

  8194. 	if (opline->extended_value & ZEND_BIND_REF) {
    8195. 

  8195. 		/* By-ref binding */
    8196. 

  8196. 		var = GET_OP2_ZVAL_PTR(BP_VAR_W);
    8197. 

  8197. 		if (Z_ISREF_P(var)) {
    8198. 

  8198. 			Z_ADDREF_P(var);
    8199. 

  8199. 		} else {
    8200. 

  8200. 			ZVAL_MAKE_REF_EX(var, 2);
    8201. 

  8201. 		}
    8202. 

  8202. 	} else {
    8203. 

  8203. 		var = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8204. 

  8204. 		if (UNEXPECTED(Z_ISUNDEF_P(var)) && !(opline->extended_value & ZEND_BIND_IMPLICIT)) {
    8205. 

  8205. 			SAVE_OPLINE();
    8206. 

  8206. 			var = ZVAL_UNDEFINED_OP2();
    8207. 

  8207. 			if (UNEXPECTED(EG(exception))) {
    8208. 

  8208. 				HANDLE_EXCEPTION();
    8209. 

  8209. 			}
    8210. 

  8210. 		}
    8211. 

  8211. 		ZVAL_DEREF(var);
    8212. 

  8212. 		Z_TRY_ADDREF_P(var);
    8213. 

  8213. 	}
    8214. 

  8214. 

  8215. 	zend_closure_bind_var_ex(closure,
    8216. 

  8216. 		(opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT)), var);
    8217. 

  8217. 	ZEND_VM_NEXT_OPCODE();
    8218. 

  8218. }
    8219. 

  8219. 

  8220. ZEND_VM_HANDLER(183, ZEND_BIND_STATIC, CV, UNUSED, REF)
    8221. 

  8221. {
    8222. 

  8222. 	USE_OPLINE
    8223. 

  8223. 	HashTable *ht;
    8224. 

  8224. 	zval *value;
    8225. 

  8225. 	zval *variable_ptr;
    8226. 

  8226. 

  8227. 	variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
    8228. 

  8228. 	i_zval_ptr_dtor(variable_ptr);
    8229. 

  8229. 

  8230. 	ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
    8231. 

  8231. 	if (!ht) {
    8232. 

  8232. 		ZEND_ASSERT(EX(func)->op_array.fn_flags & (ZEND_ACC_IMMUTABLE|ZEND_ACC_PRELOADED));
    8233. 

  8233. 		ht = zend_array_dup(EX(func)->op_array.static_variables);
    8234. 

  8234. 		ZEND_MAP_PTR_SET(EX(func)->op_array.static_variables_ptr, ht);
    8235. 

  8235. 	} else if (GC_REFCOUNT(ht) > 1) {
    8236. 

  8236. 		if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
    8237. 

  8237. 			GC_DELREF(ht);
    8238. 

  8238. 		}
    8239. 

  8239. 		ht = zend_array_dup(ht);
    8240. 

  8240. 		ZEND_MAP_PTR_SET(EX(func)->op_array.static_variables_ptr, ht);
    8241. 

  8241. 	}
    8242. 

  8242. 

  8243. 	value = (zval*)((char*)ht->arData + (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT)));
    8244. 

  8244. 

  8245. 	if (opline->extended_value & ZEND_BIND_REF) {
    8246. 

  8246. 		if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
    8247. 

  8247. 			SAVE_OPLINE();
    8248. 

  8248. 			if (UNEXPECTED(zval_update_constant_ex(value, EX(func)->op_array.scope) != SUCCESS)) {
    8249. 

  8249. 				ZVAL_NULL(variable_ptr);
    8250. 

  8250. 				HANDLE_EXCEPTION();
    8251. 

  8251. 			}
    8252. 

  8252. 		}
    8253. 

  8253. 		if (UNEXPECTED(!Z_ISREF_P(value))) {
    8254. 

  8254. 			zend_reference *ref = (zend_reference*)emalloc(sizeof(zend_reference));
    8255. 

  8255. 			GC_SET_REFCOUNT(ref, 2);
    8256. 

  8256. 			GC_TYPE_INFO(ref) = IS_REFERENCE;
    8257. 

  8257. 			ZVAL_COPY_VALUE(&ref->val, value);
    8258. 

  8258. 			ref->sources.ptr = NULL;
    8259. 

  8259. 			Z_REF_P(value) = ref;
    8260. 

  8260. 			Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
    8261. 

  8261. 			ZVAL_REF(variable_ptr, ref);
    8262. 

  8262. 		} else {
    8263. 

  8263. 			Z_ADDREF_P(value);
    8264. 

  8264. 			ZVAL_REF(variable_ptr, Z_REF_P(value));
    8265. 

  8265. 		}
    8266. 

  8266. 	} else {
    8267. 

  8267. 		ZVAL_COPY(variable_ptr, value);
    8268. 

  8268. 	}
    8269. 

  8269. 

  8270. 	ZEND_VM_NEXT_OPCODE();
    8271. 

  8271. }
    8272. 

  8272. 

  8273. ZEND_VM_HOT_HANDLER(184, ZEND_FETCH_THIS, UNUSED, UNUSED)
    8274. 

  8274. {
    8275. 

  8275. 	USE_OPLINE
    8276. 

  8276. 

  8277. 	if (EXPECTED(Z_TYPE(EX(This)) == IS_OBJECT)) {
    8278. 

  8278. 		zval *result = EX_VAR(opline->result.var);
    8279. 

  8279. 

  8280. 		ZVAL_OBJ(result, Z_OBJ(EX(This)));
    8281. 

  8281. 		Z_ADDREF_P(result);
    8282. 

  8282. 		ZEND_VM_NEXT_OPCODE();
    8283. 

  8283. 	} else {
    8284. 

  8284. 		ZEND_VM_DISPATCH_TO_HELPER(zend_this_not_in_object_context_helper);
    8285. 

  8285. 	}
    8286. 

  8286. }
    8287. 

  8287. 

  8288. ZEND_VM_HANDLER(186, ZEND_ISSET_ISEMPTY_THIS, UNUSED, UNUSED)
    8289. 

  8289. {
    8290. 

  8290. 	USE_OPLINE
    8291. 

  8291. 

  8292. 	ZVAL_BOOL(EX_VAR(opline->result.var),
    8293. 

  8293. 		(opline->extended_value & ZEND_ISEMPTY) ^
    8294. 

  8294. 		 (Z_TYPE(EX(This)) == IS_OBJECT));
    8295. 

  8295. 	ZEND_VM_NEXT_OPCODE();
    8296. 

  8296. }
    8297. 

  8297. 

  8298. ZEND_VM_HANDLER(49, ZEND_CHECK_VAR, CV, UNUSED)
    8299. 

  8299. {
    8300. 

  8300. 	USE_OPLINE
    8301. 

  8301. 	zval *op1 = EX_VAR(opline->op1.var);
    8302. 

  8302. 

  8303. 	if (UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
    8304. 

  8304. 		SAVE_OPLINE();
    8305. 

  8305. 		ZVAL_UNDEFINED_OP1();
    8306. 

  8306. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    8307. 

  8307. 	}
    8308. 

  8308. 	ZEND_VM_NEXT_OPCODE();
    8309. 

  8309. }
    8310. 

  8310. 

  8311. ZEND_VM_HANDLER(140, ZEND_MAKE_REF, VAR|CV, UNUSED)
    8312. 

  8312. {
    8313. 

  8313. 	USE_OPLINE
    8314. 

  8314. 	zval *op1 = EX_VAR(opline->op1.var);
    8315. 

  8315. 

  8316. 	if (OP1_TYPE == IS_CV) {
    8317. 

  8317. 		if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
    8318. 

  8318. 			ZVAL_NEW_EMPTY_REF(op1);
    8319. 

  8319. 			Z_SET_REFCOUNT_P(op1, 2);
    8320. 

  8320. 			ZVAL_NULL(Z_REFVAL_P(op1));
    8321. 

  8321. 			ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
    8322. 

  8322. 		} else {
    8323. 

  8323. 			if (Z_ISREF_P(op1)) {
    8324. 

  8324. 				Z_ADDREF_P(op1);
    8325. 

  8325. 			} else {
    8326. 

  8326. 				ZVAL_MAKE_REF_EX(op1, 2);
    8327. 

  8327. 			}
    8328. 

  8328. 			ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
    8329. 

  8329. 		}
    8330. 

  8330. 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
    8331. 

  8331. 		op1 = Z_INDIRECT_P(op1);
    8332. 

  8332. 		if (EXPECTED(!Z_ISREF_P(op1))) {
    8333. 

  8333. 			ZVAL_MAKE_REF_EX(op1, 2);
    8334. 

  8334. 		} else {
    8335. 

  8335. 			GC_ADDREF(Z_REF_P(op1));
    8336. 

  8336. 		}
    8337. 

  8337. 		ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
    8338. 

  8338. 	} else {
    8339. 

  8339. 		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
    8340. 

  8340. 	}
    8341. 

  8341. 	ZEND_VM_NEXT_OPCODE();
    8342. 

  8342. }
    8343. 

  8343. 

  8344. ZEND_VM_COLD_CONSTCONST_HANDLER(187, ZEND_SWITCH_LONG, CONST|TMPVARCV, CONST, JMP_ADDR)
    8345. 

  8345. {
    8346. 

  8346. 	USE_OPLINE
    8347. 

  8347. 	zval *op, *jump_zv;
    8348. 

  8348. 	HashTable *jumptable;
    8349. 

  8349. 

  8350. 	op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8351. 

  8351. 

  8352. 	if (Z_TYPE_P(op) != IS_LONG) {
    8353. 

  8353. 		ZVAL_DEREF(op);
    8354. 

  8354. 		if (Z_TYPE_P(op) != IS_LONG) {
    8355. 

  8355. 			/* Wrong type, fall back to ZEND_CASE chain */
    8356. 

  8356. 			ZEND_VM_NEXT_OPCODE();
    8357. 

  8357. 		}
    8358. 

  8358. 	}
    8359. 

  8359. 

  8360. 	jumptable = Z_ARRVAL_P(GET_OP2_ZVAL_PTR(BP_VAR_R));
    8361. 

  8361. 	jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
    8362. 

  8362. 	if (jump_zv != NULL) {
    8363. 

  8363. 		ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
    8364. 

  8364. 		ZEND_VM_CONTINUE();
    8365. 

  8365. 	} else {
    8366. 

  8366. 		/* default */
    8367. 

  8367. 		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
    8368. 

  8368. 		ZEND_VM_CONTINUE();
    8369. 

  8369. 	}
    8370. 

  8370. }
    8371. 

  8371. 

  8372. ZEND_VM_COLD_CONSTCONST_HANDLER(188, ZEND_SWITCH_STRING, CONST|TMPVARCV, CONST, JMP_ADDR)
    8373. 

  8373. {
    8374. 

  8374. 	USE_OPLINE
    8375. 

  8375. 	zval *op, *jump_zv;
    8376. 

  8376. 	HashTable *jumptable;
    8377. 

  8377. 

  8378. 	op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8379. 

  8379. 

  8380. 	if (Z_TYPE_P(op) != IS_STRING) {
    8381. 

  8381. 		if (OP1_TYPE == IS_CONST) {
    8382. 

  8382. 			/* Wrong type, fall back to ZEND_CASE chain */
    8383. 

  8383. 			ZEND_VM_NEXT_OPCODE();
    8384. 

  8384. 		} else {
    8385. 

  8385. 			ZVAL_DEREF(op);
    8386. 

  8386. 			if (Z_TYPE_P(op) != IS_STRING) {
    8387. 

  8387. 				/* Wrong type, fall back to ZEND_CASE chain */
    8388. 

  8388. 				ZEND_VM_NEXT_OPCODE();
    8389. 

  8389. 			}
    8390. 

  8390. 		}
    8391. 

  8391. 	}
    8392. 

  8392. 

  8393. 	jumptable = Z_ARRVAL_P(GET_OP2_ZVAL_PTR(BP_VAR_R));
    8394. 

  8394. 	jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), OP1_TYPE == IS_CONST);
    8395. 

  8395. 	if (jump_zv != NULL) {
    8396. 

  8396. 		ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
    8397. 

  8397. 		ZEND_VM_CONTINUE();
    8398. 

  8398. 	} else {
    8399. 

  8399. 		/* default */
    8400. 

  8400. 		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
    8401. 

  8401. 		ZEND_VM_CONTINUE();
    8402. 

  8402. 	}
    8403. 

  8403. }
    8404. 

  8404. 

  8405. ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM)
    8406. 

  8406. {
    8407. 

  8407. 	USE_OPLINE
    8408. 

  8408. 	zval *op1;
    8409. 

  8409. 	HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
    8410. 

  8410. 	zval *result;
    8411. 

  8411. 

  8412. 	SAVE_OPLINE();
    8413. 

  8413. 	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
    8414. 

  8414. 	if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
    8415. 

  8415. 		result = zend_hash_find_ex(ht, Z_STR_P(op1), OP1_TYPE == IS_CONST);
    8416. 

  8416. 	} else if (opline->extended_value) {
    8417. 

  8417. 		if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
    8418. 

  8418. 			result = zend_hash_index_find(ht, Z_LVAL_P(op1));
    8419. 

  8419. 		} else {
    8420. 

  8420. 			result = NULL;
    8421. 

  8421. 		}
    8422. 

  8422. 	} else if (Z_TYPE_P(op1) <= IS_FALSE) {
    8423. 

  8423. 		result = zend_hash_find_ex(ht, ZSTR_EMPTY_ALLOC(), 1);
    8424. 

  8424. 	} else {
    8425. 

  8425. 		zend_string *key;
    8426. 

  8426. 		zval key_tmp, *val;
    8427. 

  8427. 

  8428. 		result = NULL;
    8429. 

  8429. 		ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
    8430. 

  8430. 			ZVAL_STR(&key_tmp, key);
    8431. 

  8431. 			if (zend_compare(op1, &key_tmp) == 0) {
    8432. 

  8432. 				result = val;
    8433. 

  8433. 				break;
    8434. 

  8434. 			}
    8435. 

  8435. 		} ZEND_HASH_FOREACH_END();
    8436. 

  8436. 	}
    8437. 

  8437. 	FREE_OP1();
    8438. 

  8438. 	ZEND_VM_SMART_BRANCH(result, 1);
    8439. 

  8439. }
    8440. 

  8440. 

  8441. ZEND_VM_COLD_CONST_HANDLER(190, ZEND_COUNT, CONST|TMPVAR|CV, UNUSED)
    8442. 

  8442. {
    8443. 

  8443. 	USE_OPLINE
    8444. 

  8444. 	zval *op1;
    8445. 

  8445. 	zend_long count;
    8446. 

  8446. 

  8447. 	SAVE_OPLINE();
    8448. 

  8448. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8449. 

  8449. 	while (1) {
    8450. 

  8450. 		if (Z_TYPE_P(op1) == IS_ARRAY) {
    8451. 

  8451. 			count = zend_array_count(Z_ARRVAL_P(op1));
    8452. 

  8452. 			break;
    8453. 

  8453. 		} else if (Z_TYPE_P(op1) == IS_OBJECT) {
    8454. 

  8454. 			zend_object *zobj = Z_OBJ_P(op1);
    8455. 

  8455. 

  8456. 			/* first, we check if the handler is defined */
    8457. 

  8457. 			if (zobj->handlers->count_elements) {
    8458. 

  8458. 				if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
    8459. 

  8459. 					break;
    8460. 

  8460. 				}
    8461. 

  8461. 				if (UNEXPECTED(EG(exception))) {
    8462. 

  8462. 					count = 0;
    8463. 

  8463. 					break;
    8464. 

  8464. 				}
    8465. 

  8465. 			}
    8466. 

  8466. 

  8467. 			/* if not and the object implements Countable we call its count() method */
    8468. 

  8468. 			if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
    8469. 

  8469. 				zval retval;
    8470. 

  8470. 

  8471. 				zend_call_method_with_0_params(zobj, NULL, NULL, "count", &retval);
    8472. 

  8472. 				count = zval_get_long(&retval);
    8473. 

  8473. 				zval_ptr_dtor(&retval);
    8474. 

  8474. 				break;
    8475. 

  8475. 			}
    8476. 

  8476. 

  8477. 			/* If There's no handler and it doesn't implement Countable then add a warning */
    8478. 

  8478. 			count = 1;
    8479. 

  8479. 		} else if ((OP1_TYPE & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
    8480. 

  8480. 			op1 = Z_REFVAL_P(op1);
    8481. 

  8481. 			continue;
    8482. 

  8482. 		} else if (Z_TYPE_P(op1) <= IS_NULL) {
    8483. 

  8483. 			if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
    8484. 

  8484. 				ZVAL_UNDEFINED_OP1();
    8485. 

  8485. 			}
    8486. 

  8486. 			count = 0;
    8487. 

  8487. 		} else {
    8488. 

  8488. 			count = 1;
    8489. 

  8489. 		}
    8490. 

  8490. 		zend_error(E_WARNING, "%s(): Parameter must be an array or an object that implements Countable", opline->extended_value ? "sizeof" : "count");
    8491. 

  8491. 		break;
    8492. 

  8492. 	}
    8493. 

  8493. 

  8494. 	ZVAL_LONG(EX_VAR(opline->result.var), count);
    8495. 

  8495. 	FREE_OP1();
    8496. 

  8496. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    8497. 

  8497. }
    8498. 

  8498. 

  8499. ZEND_VM_COLD_CONST_HANDLER(191, ZEND_GET_CLASS, UNUSED|CONST|TMPVAR|CV, UNUSED)
    8500. 

  8500. {
    8501. 

  8501. 	USE_OPLINE
    8502. 

  8502. 

  8503. 	if (OP1_TYPE == IS_UNUSED) {
    8504. 

  8504. 		if (UNEXPECTED(!EX(func)->common.scope)) {
    8505. 

  8505. 			SAVE_OPLINE();
    8506. 

  8506. 			zend_error(E_WARNING, "get_class() called without object from outside a class");
    8507. 

  8507. 			ZVAL_FALSE(EX_VAR(opline->result.var));
    8508. 

  8508. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    8509. 

  8509. 		} else {
    8510. 

  8510. 			ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
    8511. 

  8511. 			ZEND_VM_NEXT_OPCODE();
    8512. 

  8512. 		}
    8513. 

  8513. 	} else {
    8514. 

  8514. 		zval *op1;
    8515. 

  8515. 

  8516. 		SAVE_OPLINE();
    8517. 

  8517. 		op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8518. 

  8518. 		while (1) {
    8519. 

  8519. 			if (Z_TYPE_P(op1) == IS_OBJECT) {
    8520. 

  8520. 				ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
    8521. 

  8521. 			} else if ((OP1_TYPE & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
    8522. 

  8522. 				op1 = Z_REFVAL_P(op1);
    8523. 

  8523. 				continue;
    8524. 

  8524. 			} else {
    8525. 

  8525. 				if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
    8526. 

  8526. 					ZVAL_UNDEFINED_OP1();
    8527. 

  8527. 				}
    8528. 

  8528. 				zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
    8529. 

  8529. 				ZVAL_UNDEF(EX_VAR(opline->result.var));
    8530. 

  8530. 			}
    8531. 

  8531. 			break;
    8532. 

  8532. 		}
    8533. 

  8533. 		FREE_OP1();
    8534. 

  8534. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    8535. 

  8535. 	}
    8536. 

  8536. }
    8537. 

  8537. 

  8538. ZEND_VM_HANDLER(192, ZEND_GET_CALLED_CLASS, UNUSED, UNUSED)
    8539. 

  8539. {
    8540. 

  8540. 	USE_OPLINE
    8541. 

  8541. 

  8542. 	if (Z_TYPE(EX(This)) == IS_OBJECT) {
    8543. 

  8543. 		ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
    8544. 

  8544. 	} else if (Z_CE(EX(This))) {
    8545. 

  8545. 		ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
    8546. 

  8546. 	} else {
    8547. 

  8547. 		ZVAL_FALSE(EX_VAR(opline->result.var));
    8548. 

  8548. 		if (UNEXPECTED(!EX(func)->common.scope)) {
    8549. 

  8549. 			SAVE_OPLINE();
    8550. 

  8550. 			zend_error(E_WARNING, "get_called_class() called from outside a class");
    8551. 

  8551. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    8552. 

  8552. 		}
    8553. 

  8553. 	}
    8554. 

  8554. 	ZEND_VM_NEXT_OPCODE();
    8555. 

  8555. }
    8556. 

  8556. 

  8557. ZEND_VM_COLD_CONST_HANDLER(193, ZEND_GET_TYPE, CONST|TMP|VAR|CV, UNUSED)
    8558. 

  8558. {
    8559. 

  8559. 	USE_OPLINE
    8560. 

  8560. 	zval *op1;
    8561. 

  8561. 	zend_string *type;
    8562. 

  8562. 

  8563. 	SAVE_OPLINE();
    8564. 

  8564. 	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
    8565. 

  8565. 	type = zend_zval_get_type(op1);
    8566. 

  8566. 	if (EXPECTED(type)) {
    8567. 

  8567. 		ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
    8568. 

  8568. 	} else {
    8569. 

  8569. 		ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
    8570. 

  8570. 	}
    8571. 

  8571. 	FREE_OP1();
    8572. 

  8572. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    8573. 

  8573. }
    8574. 

  8574. 

  8575. ZEND_VM_HANDLER(171, ZEND_FUNC_NUM_ARGS, UNUSED, UNUSED)
    8576. 

  8576. {
    8577. 

  8577. 	USE_OPLINE
    8578. 

  8578. 

  8579. 	ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
    8580. 

  8580. 	ZEND_VM_NEXT_OPCODE();
    8581. 

  8581. }
    8582. 

  8582. 

  8583. ZEND_VM_HANDLER(172, ZEND_FUNC_GET_ARGS, UNUSED|CONST, UNUSED)
    8584. 

  8584. {
    8585. 

  8585. 	USE_OPLINE
    8586. 

  8586. 	zend_array *ht;
    8587. 

  8587. 	uint32_t arg_count, result_size, skip;
    8588. 

  8588. 

  8589. 	arg_count = EX_NUM_ARGS();
    8590. 

  8590. 	if (OP1_TYPE == IS_CONST) {
    8591. 

  8591. 		skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
    8592. 

  8592. 		if (arg_count < skip) {
    8593. 

  8593. 			result_size = 0;
    8594. 

  8594. 		} else {
    8595. 

  8595. 			result_size = arg_count - skip;
    8596. 

  8596. 		}
    8597. 

  8597. 	} else {
    8598. 

  8598. 		skip = 0;
    8599. 

  8599. 		result_size = arg_count;
    8600. 

  8600. 	}
    8601. 

  8601. 

  8602. 	if (result_size) {
    8603. 

  8603. 		uint32_t first_extra_arg = EX(func)->op_array.num_args;
    8604. 

  8604. 

  8605. 		ht = zend_new_array(result_size);
    8606. 

  8606. 		ZVAL_ARR(EX_VAR(opline->result.var), ht);
    8607. 

  8607. 		zend_hash_real_init_packed(ht);
    8608. 

  8608. 		ZEND_HASH_FILL_PACKED(ht) {
    8609. 

  8609. 			zval *p, *q;
    8610. 

  8610. 			uint32_t i = skip;
    8611. 

  8611. 			p = EX_VAR_NUM(i);
    8612. 

  8612. 			if (arg_count > first_extra_arg) {
    8613. 

  8613. 				while (i < first_extra_arg) {
    8614. 

  8614. 					q = p;
    8615. 

  8615. 					if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
    8616. 

  8616. 						ZVAL_DEREF(q);
    8617. 

  8617. 						if (Z_OPT_REFCOUNTED_P(q)) {
    8618. 

  8618. 							Z_ADDREF_P(q);
    8619. 

  8619. 						}
    8620. 

  8620. 						ZEND_HASH_FILL_SET(q);
    8621. 

  8621. 					} else {
    8622. 

  8622. 						ZEND_HASH_FILL_SET_NULL();
    8623. 

  8623. 					}
    8624. 

  8624. 					ZEND_HASH_FILL_NEXT();
    8625. 

  8625. 					p++;
    8626. 

  8626. 					i++;
    8627. 

  8627. 				}
    8628. 

  8628. 				if (skip < first_extra_arg) {
    8629. 

  8629. 					skip = 0;
    8630. 

  8630. 				} else {
    8631. 

  8631. 					skip -= first_extra_arg;
    8632. 

  8632. 				}
    8633. 

  8633. 				p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
    8634. 

  8634. 			}
    8635. 

  8635. 			while (i < arg_count) {
    8636. 

  8636. 				q = p;
    8637. 

  8637. 				if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
    8638. 

  8638. 					ZVAL_DEREF(q);
    8639. 

  8639. 					if (Z_OPT_REFCOUNTED_P(q)) {
    8640. 

  8640. 						Z_ADDREF_P(q);
    8641. 

  8641. 					}
    8642. 

  8642. 					ZEND_HASH_FILL_SET(q);
    8643. 

  8643. 				} else {
    8644. 

  8644. 					ZEND_HASH_FILL_SET_NULL();
    8645. 

  8645. 				}
    8646. 

  8646. 				ZEND_HASH_FILL_NEXT();
    8647. 

  8647. 				p++;
    8648. 

  8648. 				i++;
    8649. 

  8649. 			}
    8650. 

  8650. 		} ZEND_HASH_FILL_END();
    8651. 

  8651. 		ht->nNumOfElements = result_size;
    8652. 

  8652. 	} else {
    8653. 

  8653. 		ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
    8654. 

  8654. 	}
    8655. 

  8655. 	ZEND_VM_NEXT_OPCODE();
    8656. 

  8656. }
    8657. 

  8657. 

  8658. ZEND_VM_HANDLER(167, ZEND_COPY_TMP, TMPVAR, UNUSED)
    8659. 

  8659. {
    8660. 

  8660. 	USE_OPLINE
    8661. 

  8661. 	zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
    8662. 

  8662. 	zval *result = EX_VAR(opline->result.var);
    8663. 

  8663. 	ZVAL_COPY(result, value);
    8664. 

  8664. 	ZEND_VM_NEXT_OPCODE();
    8665. 

  8665. }
    8666. 

  8666. 

  8667. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_JMP, (OP_JMP_ADDR(op, op->op1) > op), ZEND_JMP_FORWARD, JMP_ADDR, ANY)
    8668. 

  8668. {
    8669. 

  8669. 	USE_OPLINE
    8670. 

  8670. 

  8671. 	OPLINE = OP_JMP_ADDR(opline, opline->op1);
    8672. 

  8672. 	ZEND_VM_CONTINUE();
    8673. 

  8673. }
    8674. 

  8674. 

  8675. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_ADD, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_ADD_LONG_NO_OVERFLOW, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
    8676. 

  8676. {
    8677. 

  8677. 	USE_OPLINE
    8678. 

  8678. 	zval *op1, *op2, *result;
    8679. 

  8679. 

  8680. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8681. 

  8681. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8682. 

  8682. 	result = EX_VAR(opline->result.var);
    8683. 

  8683. 	ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
    8684. 

  8684. 	ZEND_VM_NEXT_OPCODE();
    8685. 

  8685. }
    8686. 

  8686. 

  8687. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_ADD, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_ADD_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
    8688. 

  8688. {
    8689. 

  8689. 	USE_OPLINE
    8690. 

  8690. 	zval *op1, *op2, *result;
    8691. 

  8691. 

  8692. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8693. 

  8693. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8694. 

  8694. 	result = EX_VAR(opline->result.var);
    8695. 

  8695. 	fast_long_add_function(result, op1, op2);
    8696. 

  8696. 	ZEND_VM_NEXT_OPCODE();
    8697. 

  8697. }
    8698. 

  8698. 

  8699. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_ADD, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_ADD_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
    8700. 

  8700. {
    8701. 

  8701. 	USE_OPLINE
    8702. 

  8702. 	zval *op1, *op2, *result;
    8703. 

  8703. 

  8704. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8705. 

  8705. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8706. 

  8706. 	result = EX_VAR(opline->result.var);
    8707. 

  8707. 	ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
    8708. 

  8708. 	ZEND_VM_NEXT_OPCODE();
    8709. 

  8709. }
    8710. 

  8710. 

  8711. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SUB, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_SUB_LONG_NO_OVERFLOW, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST))
    8712. 

  8712. {
    8713. 

  8713. 	USE_OPLINE
    8714. 

  8714. 	zval *op1, *op2, *result;
    8715. 

  8715. 

  8716. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8717. 

  8717. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8718. 

  8718. 	result = EX_VAR(opline->result.var);
    8719. 

  8719. 	ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
    8720. 

  8720. 	ZEND_VM_NEXT_OPCODE();
    8721. 

  8721. }
    8722. 

  8722. 

  8723. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SUB, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_SUB_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST))
    8724. 

  8724. {
    8725. 

  8725. 	USE_OPLINE
    8726. 

  8726. 	zval *op1, *op2, *result;
    8727. 

  8727. 

  8728. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8729. 

  8729. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8730. 

  8730. 	result = EX_VAR(opline->result.var);
    8731. 

  8731. 	fast_long_sub_function(result, op1, op2);
    8732. 

  8732. 	ZEND_VM_NEXT_OPCODE();
    8733. 

  8733. }
    8734. 

  8734. 

  8735. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SUB, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_SUB_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST))
    8736. 

  8736. {
    8737. 

  8737. 	USE_OPLINE
    8738. 

  8738. 	zval *op1, *op2, *result;
    8739. 

  8739. 

  8740. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8741. 

  8741. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8742. 

  8742. 	result = EX_VAR(opline->result.var);
    8743. 

  8743. 	ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
    8744. 

  8744. 	ZEND_VM_NEXT_OPCODE();
    8745. 

  8745. }
    8746. 

  8746. 

  8747. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_MUL, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_MUL_LONG_NO_OVERFLOW, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
    8748. 

  8748. {
    8749. 

  8749. 	USE_OPLINE
    8750. 

  8750. 	zval *op1, *op2, *result;
    8751. 

  8751. 

  8752. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8753. 

  8753. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8754. 

  8754. 	result = EX_VAR(opline->result.var);
    8755. 

  8755. 	ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
    8756. 

  8756. 	ZEND_VM_NEXT_OPCODE();
    8757. 

  8757. }
    8758. 

  8758. 

  8759. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_MUL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_MUL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
    8760. 

  8760. {
    8761. 

  8761. 	USE_OPLINE
    8762. 

  8762. 	zval *op1, *op2, *result;
    8763. 

  8763. 	zend_long overflow;
    8764. 

  8764. 

  8765. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8766. 

  8766. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8767. 

  8767. 	result = EX_VAR(opline->result.var);
    8768. 

  8768. 	ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
    8769. 

  8769. 	Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
    8770. 

  8770. 	ZEND_VM_NEXT_OPCODE();
    8771. 

  8771. }
    8772. 

  8772. 

  8773. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_MUL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_MUL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
    8774. 

  8774. {
    8775. 

  8775. 	USE_OPLINE
    8776. 

  8776. 	zval *op1, *op2, *result;
    8777. 

  8777. 

  8778. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8779. 

  8779. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8780. 

  8780. 	result = EX_VAR(opline->result.var);
    8781. 

  8781. 	ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
    8782. 

  8782. 	ZEND_VM_NEXT_OPCODE();
    8783. 

  8783. }
    8784. 

  8784. 

  8785. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL|ZEND_IS_IDENTICAL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_EQUAL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
    8786. 

  8786. {
    8787. 

  8787. 	USE_OPLINE
    8788. 

  8788. 	zval *op1, *op2;
    8789. 

  8789. 	int result;
    8790. 

  8790. 

  8791. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8792. 

  8792. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8793. 

  8793. 	result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
    8794. 

  8794. 	ZEND_VM_SMART_BRANCH(result, 0);
    8795. 

  8795. }
    8796. 

  8796. 

  8797. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL|ZEND_IS_IDENTICAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
    8798. 

  8798. {
    8799. 

  8799. 	USE_OPLINE
    8800. 

  8800. 	zval *op1, *op2;
    8801. 

  8801. 	int result;
    8802. 

  8802. 

  8803. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8804. 

  8804. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8805. 

  8805. 	result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
    8806. 

  8806. 	ZEND_VM_SMART_BRANCH(result, 0);
    8807. 

  8807. }
    8808. 

  8808. 

  8809. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL|ZEND_IS_NOT_IDENTICAL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_NOT_EQUAL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
    8810. 

  8810. {
    8811. 

  8811. 	USE_OPLINE
    8812. 

  8812. 	zval *op1, *op2;
    8813. 

  8813. 	int result;
    8814. 

  8814. 

  8815. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8816. 

  8816. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8817. 

  8817. 	result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
    8818. 

  8818. 	ZEND_VM_SMART_BRANCH(result, 0);
    8819. 

  8819. }
    8820. 

  8820. 

  8821. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL|ZEND_IS_NOT_IDENTICAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_NOT_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
    8822. 

  8822. {
    8823. 

  8823. 	USE_OPLINE
    8824. 

  8824. 	zval *op1, *op2;
    8825. 

  8825. 	int result;
    8826. 

  8826. 

  8827. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8828. 

  8828. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8829. 

  8829. 	result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
    8830. 

  8830. 	ZEND_VM_SMART_BRANCH(result, 0);
    8831. 

  8831. }
    8832. 

  8832. 

  8833. ZEND_VM_TYPE_SPEC_HANDLER(ZEND_IS_IDENTICAL, op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF)), ZEND_IS_IDENTICAL_NOTHROW, CV, CONST|CV, SPEC(COMMUTATIVE))
    8834. 

  8834. {
    8835. 

  8835. 	/* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
    8836. 

  8836. 	/* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
    8837. 

  8837. 	/* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
    8838. 

  8838. 	USE_OPLINE
    8839. 

  8839. 	zval *op1, *op2;
    8840. 

  8840. 	zend_bool result;
    8841. 

  8841. 

  8842. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8843. 

  8843. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8844. 

  8844. 	result = fast_is_identical_function(op1, op2);
    8845. 

  8845. 	/* Free is a no-op for const/cv */
    8846. 

  8846. 	ZEND_VM_SMART_BRANCH(result, 0);
    8847. 

  8847. }
    8848. 

  8848. 

  8849. ZEND_VM_TYPE_SPEC_HANDLER(ZEND_IS_NOT_IDENTICAL, op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF)), ZEND_IS_NOT_IDENTICAL_NOTHROW, CV, CONST|CV, SPEC(COMMUTATIVE))
    8850. 

  8850. {
    8851. 

  8851. 	USE_OPLINE
    8852. 

  8852. 	zval *op1, *op2;
    8853. 

  8853. 	zend_bool result;
    8854. 

  8854. 

  8855. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8856. 

  8856. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8857. 

  8857. 	result = fast_is_identical_function(op1, op2);
    8858. 

  8858. 	/* Free is a no-op for const/cv */
    8859. 

  8859. 	ZEND_VM_SMART_BRANCH(!result, 0);
    8860. 

  8860. }
    8861. 

  8861. 

  8862. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_SMALLER_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
    8863. 

  8863. {
    8864. 

  8864. 	USE_OPLINE
    8865. 

  8865. 	zval *op1, *op2;
    8866. 

  8866. 	int result;
    8867. 

  8867. 

  8868. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8869. 

  8869. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8870. 

  8870. 	result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
    8871. 

  8871. 	ZEND_VM_SMART_BRANCH(result, 0);
    8872. 

  8872. }
    8873. 

  8873. 

  8874. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_SMALLER_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
    8875. 

  8875. {
    8876. 

  8876. 	USE_OPLINE
    8877. 

  8877. 	zval *op1, *op2;
    8878. 

  8878. 	int result;
    8879. 

  8879. 

  8880. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8881. 

  8881. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8882. 

  8882. 	result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
    8883. 

  8883. 	ZEND_VM_SMART_BRANCH(result, 0);
    8884. 

  8884. }
    8885. 

  8885. 

  8886. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_SMALLER_OR_EQUAL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
    8887. 

  8887. {
    8888. 

  8888. 	USE_OPLINE
    8889. 

  8889. 	zval *op1, *op2;
    8890. 

  8890. 	int result;
    8891. 

  8891. 

  8892. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8893. 

  8893. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8894. 

  8894. 	result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
    8895. 

  8895. 	ZEND_VM_SMART_BRANCH(result, 0);
    8896. 

  8896. }
    8897. 

  8897. 

  8898. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_SMALLER_OR_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
    8899. 

  8899. {
    8900. 

  8900. 	USE_OPLINE
    8901. 

  8901. 	zval *op1, *op2;
    8902. 

  8902. 	int result;
    8903. 

  8903. 

  8904. 	op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    8905. 

  8905. 	op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    8906. 

  8906. 	result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
    8907. 

  8907. 	ZEND_VM_SMART_BRANCH(result, 0);
    8908. 

  8908. }
    8909. 

  8909. 

  8910. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG_NO_OVERFLOW, CV, ANY, SPEC(RETVAL))
    8911. 

  8911. {
    8912. 

  8912. 	USE_OPLINE
    8913. 

  8913. 	zval *var_ptr;
    8914. 

  8914. 

  8915. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    8916. 

  8916. 	Z_LVAL_P(var_ptr)++;
    8917. 

  8917. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    8918. 

  8918. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
    8919. 

  8919. 	}
    8920. 

  8920. 	ZEND_VM_NEXT_OPCODE();
    8921. 

  8921. }
    8922. 

  8922. 

  8923. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG, CV, ANY, SPEC(RETVAL))
    8924. 

  8924. {
    8925. 

  8925. 	USE_OPLINE
    8926. 

  8926. 	zval *var_ptr;
    8927. 

  8927. 

  8928. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    8929. 

  8929. 	fast_long_increment_function(var_ptr);
    8930. 

  8930. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    8931. 

  8931. 		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
    8932. 

  8932. 	}
    8933. 

  8933. 	ZEND_VM_NEXT_OPCODE();
    8934. 

  8934. }
    8935. 

  8935. 

  8936. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_DEC_LONG_NO_OVERFLOW, CV, ANY, SPEC(RETVAL))
    8937. 

  8937. {
    8938. 

  8938. 	USE_OPLINE
    8939. 

  8939. 	zval *var_ptr;
    8940. 

  8940. 

  8941. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    8942. 

  8942. 	Z_LVAL_P(var_ptr)--;
    8943. 

  8943. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    8944. 

  8944. 		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
    8945. 

  8945. 	}
    8946. 

  8946. 	ZEND_VM_NEXT_OPCODE();
    8947. 

  8947. }
    8948. 

  8948. 

  8949. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == MAY_BE_LONG), ZEND_PRE_DEC_LONG, CV, ANY, SPEC(RETVAL))
    8950. 

  8950. {
    8951. 

  8951. 	USE_OPLINE
    8952. 

  8952. 	zval *var_ptr;
    8953. 

  8953. 

  8954. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    8955. 

  8955. 	fast_long_decrement_function(var_ptr);
    8956. 

  8956. 	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
    8957. 

  8957. 		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
    8958. 

  8958. 	}
    8959. 

  8959. 	ZEND_VM_NEXT_OPCODE();
    8960. 

  8960. }
    8961. 

  8961. 

  8962. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_POST_INC_LONG_NO_OVERFLOW, CV, ANY)
    8963. 

  8963. {
    8964. 

  8964. 	USE_OPLINE
    8965. 

  8965. 	zval *var_ptr;
    8966. 

  8966. 

  8967. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    8968. 

  8968. 	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
    8969. 

  8969. 	Z_LVAL_P(var_ptr)++;
    8970. 

  8970. 	ZEND_VM_NEXT_OPCODE();
    8971. 

  8971. }
    8972. 

  8972. 

  8973. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == MAY_BE_LONG), ZEND_POST_INC_LONG, CV, ANY)
    8974. 

  8974. {
    8975. 

  8975. 	USE_OPLINE
    8976. 

  8976. 	zval *var_ptr;
    8977. 

  8977. 

  8978. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    8979. 

  8979. 	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
    8980. 

  8980. 	fast_long_increment_function(var_ptr);
    8981. 

  8981. 	ZEND_VM_NEXT_OPCODE();
    8982. 

  8982. }
    8983. 

  8983. 

  8984. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_POST_DEC_LONG_NO_OVERFLOW, CV, ANY)
    8985. 

  8985. {
    8986. 

  8986. 	USE_OPLINE
    8987. 

  8987. 	zval *var_ptr;
    8988. 

  8988. 

  8989. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    8990. 

  8990. 	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
    8991. 

  8991. 	Z_LVAL_P(var_ptr)--;
    8992. 

  8992. 	ZEND_VM_NEXT_OPCODE();
    8993. 

  8993. }
    8994. 

  8994. 

  8995. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == MAY_BE_LONG), ZEND_POST_DEC_LONG, CV, ANY)
    8996. 

  8996. {
    8997. 

  8997. 	USE_OPLINE
    8998. 

  8998. 	zval *var_ptr;
    8999. 

  8999. 

  9000. 	var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
    9001. 

  9001. 	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
    9002. 

  9002. 	fast_long_decrement_function(var_ptr);
    9003. 

  9003. 	ZEND_VM_NEXT_OPCODE();
    9004. 

  9004. }
    9005. 

  9005. 

  9006. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_QM_ASSIGN, (op1_info == MAY_BE_LONG), ZEND_QM_ASSIGN_LONG, CONST|TMPVARCV, ANY)
    9007. 

  9007. {
    9008. 

  9008. 	USE_OPLINE
    9009. 

  9009. 	zval *value;
    9010. 

  9010. 

  9011. 	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    9012. 

  9012. 	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
    9013. 

  9013. 	ZEND_VM_NEXT_OPCODE();
    9014. 

  9014. }
    9015. 

  9015. 

  9016. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_QM_ASSIGN, (op1_info == MAY_BE_DOUBLE), ZEND_QM_ASSIGN_DOUBLE, CONST|TMPVARCV, ANY)
    9017. 

  9017. {
    9018. 

  9018. 	USE_OPLINE
    9019. 

  9019. 	zval *value;
    9020. 

  9020. 

  9021. 	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    9022. 

  9022. 	ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
    9023. 

  9023. 	ZEND_VM_NEXT_OPCODE();
    9024. 

  9024. }
    9025. 

  9025. 

  9026. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_QM_ASSIGN, ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))), ZEND_QM_ASSIGN_NOREF, CONST|TMPVARCV, ANY)
    9027. 

  9027. {
    9028. 

  9028. 	USE_OPLINE
    9029. 

  9029. 	zval *value;
    9030. 

  9030. 

  9031. 	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    9032. 

  9032. 	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
    9033. 

  9033. 	ZEND_VM_NEXT_OPCODE();
    9034. 

  9034. }
    9035. 

  9035. 

  9036. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_FETCH_DIM_R, (!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))), ZEND_FETCH_DIM_R_INDEX, CONST|TMPVAR|CV, CONST|TMPVARCV, SPEC(NO_CONST_CONST))
    9037. 

  9037. {
    9038. 

  9038. 	USE_OPLINE
    9039. 

  9039. 	zval *container, *dim, *value;
    9040. 

  9040. 	zend_long offset;
    9041. 

  9041. 	HashTable *ht;
    9042. 

  9042. 

  9043. 	container = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    9044. 

  9044. 	dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
    9045. 

  9045. 	if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    9046. 

  9046. ZEND_VM_C_LABEL(fetch_dim_r_index_array):
    9047. 

  9047. 		if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
    9048. 

  9048. 			offset = Z_LVAL_P(dim);
    9049. 

  9049. 		} else {
    9050. 

  9050. 			offset = zval_get_long(dim);
    9051. 

  9051. 		}
    9052. 

  9052. 		ht = Z_ARRVAL_P(container);
    9053. 

  9053. 		ZEND_HASH_INDEX_FIND(ht, offset, value, ZEND_VM_C_LABEL(fetch_dim_r_index_undef));
    9054. 

  9054. 		ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
    9055. 

  9055. 		if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
    9056. 

  9056. 			SAVE_OPLINE();
    9057. 

  9057. 			FREE_OP1();
    9058. 

  9058. 			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    9059. 

  9059. 		} else {
    9060. 

  9060. 			ZEND_VM_NEXT_OPCODE();
    9061. 

  9061. 		}
    9062. 

  9062. 	} else if (OP1_TYPE != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
    9063. 

  9063. 		container = Z_REFVAL_P(container);
    9064. 

  9064. 		if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
    9065. 

  9065. 			ZEND_VM_C_GOTO(fetch_dim_r_index_array);
    9066. 

  9066. 		} else {
    9067. 

  9067. 			ZEND_VM_C_GOTO(fetch_dim_r_index_slow);
    9068. 

  9068. 		}
    9069. 

  9069. 	} else {
    9070. 

  9070. ZEND_VM_C_LABEL(fetch_dim_r_index_slow):
    9071. 

  9071. 		SAVE_OPLINE();
    9072. 

  9072. 		if (OP2_TYPE == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
    9073. 

  9073. 			dim++;
    9074. 

  9074. 		}
    9075. 

  9075. 		zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
    9076. 

  9076. 		FREE_OP1();
    9077. 

  9077. 		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    9078. 

  9078. 	}
    9079. 

  9079. 

  9080. ZEND_VM_C_LABEL(fetch_dim_r_index_undef):
    9081. 

  9081. 	ZVAL_NULL(EX_VAR(opline->result.var));
    9082. 

  9082. 	SAVE_OPLINE();
    9083. 

  9083. 	zend_undefined_offset(offset);
    9084. 

  9084. 	FREE_OP1();
    9085. 

  9085. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    9086. 

  9086. }
    9087. 

  9087. 

  9088. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAR, (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0, ZEND_SEND_VAR_SIMPLE, CV|VAR, NUM)
    9089. 

  9089. {
    9090. 

  9090. 	USE_OPLINE
    9091. 

  9091. 	zval *varptr, *arg;
    9092. 

  9092. 

  9093. 	varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    9094. 

  9094. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    9095. 

  9095. 

  9096. 	if (OP1_TYPE == IS_CV) {
    9097. 

  9097. 		ZVAL_COPY(arg, varptr);
    9098. 

  9098. 	} else /* if (OP1_TYPE == IS_VAR) */ {
    9099. 

  9099. 		ZVAL_COPY_VALUE(arg, varptr);
    9100. 

  9100. 	}
    9101. 

  9101. 

  9102. 	ZEND_VM_NEXT_OPCODE();
    9103. 

  9103. }
    9104. 

  9104. 

  9105. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAR_EX, op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0, ZEND_SEND_VAR_EX_SIMPLE, CV|VAR, NUM)
    9106. 

  9106. {
    9107. 

  9107. 	USE_OPLINE
    9108. 

  9108. 	zval *varptr, *arg;
    9109. 

  9109. 	uint32_t arg_num = opline->op2.num;
    9110. 

  9110. 

  9111. 	if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    9112. 

  9112. 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF);
    9113. 

  9113. 	}
    9114. 

  9114. 

  9115. 	varptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
    9116. 

  9116. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    9117. 

  9117. 

  9118. 	if (OP1_TYPE == IS_CV) {
    9119. 

  9119. 		ZVAL_COPY(arg, varptr);
    9120. 

  9120. 	} else /* if (OP1_TYPE == IS_VAR) */ {
    9121. 

  9121. 		ZVAL_COPY_VALUE(arg, varptr);
    9122. 

  9122. 	}
    9123. 

  9123. 

  9124. 	ZEND_VM_NEXT_OPCODE();
    9125. 

  9125. }
    9126. 

  9126. 

  9127. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAL, op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)), ZEND_SEND_VAL_SIMPLE, CONST, NUM)
    9128. 

  9128. {
    9129. 

  9129. 	USE_OPLINE
    9130. 

  9130. 	zval *value, *arg;
    9131. 

  9131. 

  9132. 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
    9133. 

  9133. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    9134. 

  9134. 	ZVAL_COPY_VALUE(arg, value);
    9135. 

  9135. 	ZEND_VM_NEXT_OPCODE();
    9136. 

  9136. }
    9137. 

  9137. 

  9138. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_SEND_VAL_EX, op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)), ZEND_SEND_VAL_EX_SIMPLE, CONST, NUM)
    9139. 

  9139. {
    9140. 

  9140. 	USE_OPLINE
    9141. 

  9141. 	zval *value, *arg;
    9142. 

  9142. 	uint32_t arg_num = opline->op2.num;
    9143. 

  9143. 

  9144. 	if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
    9145. 

  9145. 		ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper);
    9146. 

  9146. 	}
    9147. 

  9147. 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
    9148. 

  9148. 	arg = ZEND_CALL_VAR(EX(call), opline->result.var);
    9149. 

  9149. 	ZVAL_COPY_VALUE(arg, value);
    9150. 

  9150. 	ZEND_VM_NEXT_OPCODE();
    9151. 

  9151. }
    9152. 

  9152. 

  9153. ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_FE_FETCH_R, op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY, ZEND_FE_FETCH_R_SIMPLE, VAR, CV, JMP_ADDR, SPEC(RETVAL))
    9154. 

  9154. {
    9155. 

  9155. 	USE_OPLINE
    9156. 

  9156. 	zval *array;
    9157. 

  9157. 	zval *value, *variable_ptr;
    9158. 

  9158. 	uint32_t value_type;
    9159. 

  9159. 	HashTable *fe_ht;
    9160. 

  9160. 	HashPosition pos;
    9161. 

  9161. 	Bucket *p;
    9162. 

  9162. 

  9163. 	array = EX_VAR(opline->op1.var);
    9164. 

  9164. 	SAVE_OPLINE();
    9165. 

  9165. 	fe_ht = Z_ARRVAL_P(array);
    9166. 

  9166. 	pos = Z_FE_POS_P(array);
    9167. 

  9167. 	p = fe_ht->arData + pos;
    9168. 

  9168. 	while (1) {
    9169. 

  9169. 		if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
    9170. 

  9170. 			/* reached end of iteration */
    9171. 

  9171. 			ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
    9172. 

  9172. 			ZEND_VM_CONTINUE();
    9173. 

  9173. 		}
    9174. 

  9174. 		value = &p->val;
    9175. 

  9175. 		value_type = Z_TYPE_INFO_P(value);
    9176. 

  9176. 		if (EXPECTED(value_type != IS_UNDEF)) {
    9177. 

  9177. 			if (UNEXPECTED(value_type == IS_INDIRECT)) {
    9178. 

  9178. 				value = Z_INDIRECT_P(value);
    9179. 

  9179. 				value_type = Z_TYPE_INFO_P(value);
    9180. 

  9180. 				if (EXPECTED(value_type != IS_UNDEF)) {
    9181. 

  9181. 					break;
    9182. 

  9182. 				}
    9183. 

  9183. 			} else {
    9184. 

  9184. 				break;
    9185. 

  9185. 			}
    9186. 

  9186. 		}
    9187. 

  9187. 		pos++;
    9188. 

  9188. 		p++;
    9189. 

  9189. 	}
    9190. 

  9190. 	Z_FE_POS_P(array) = pos + 1;
    9191. 

  9191. 	if (RETURN_VALUE_USED(opline)) {
    9192. 

  9192. 		if (!p->key) {
    9193. 

  9193. 			ZVAL_LONG(EX_VAR(opline->result.var), p->h);
    9194. 

  9194. 		} else {
    9195. 

  9195. 			ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
    9196. 

  9196. 		}
    9197. 

  9197. 	}
    9198. 

  9198. 

  9199. 	variable_ptr = EX_VAR(opline->op2.var);
    9200. 

  9200. 	zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
    9201. 

  9201. 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
    9202. 

  9202. }
    9203. 

  9203. 

  9204. ZEND_VM_DEFINE_OP(137, ZEND_OP_DATA);
    9205. 

  9205. 

  9206. ZEND_VM_HELPER(zend_interrupt_helper, ANY, ANY)
    9207. 

  9207. {
    9208. 

  9208. 	EG(vm_interrupt) = 0;
    9209. 

  9209. 	SAVE_OPLINE();
    9210. 

  9210. 	if (EG(timed_out)) {
    9211. 

  9211. 		zend_timeout(0);
    9212. 

  9212. 	} else if (zend_interrupt_function) {
    9213. 

  9213. 		zend_interrupt_function(execute_data);
    9214. 

  9214. 		ZEND_VM_ENTER();
    9215. 

  9215. 	}
    9216. 

  9216. 	ZEND_VM_CONTINUE();
    9217. 

  9217. }
    9218. 

  9218.