root/Zend/zend_vm_execute.h

/* [<][>][^][v][top][bottom][index][help] */

INCLUDED FROM

DEFINITIONS

This source file includes following definitions.
  1. execute_ex
  2. zend_execute
  3. zend_leave_helper_SPEC
  4. zend_do_fcall_common_helper_SPEC
  5. ZEND_JMP_SPEC_HANDLER
  6. ZEND_INIT_STRING_SPEC_HANDLER
  7. ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER
  8. ZEND_GENERATOR_RETURN_SPEC_HANDLER
  9. ZEND_SEND_UNPACK_SPEC_HANDLER
  10. ZEND_RECV_SPEC_HANDLER
  11. ZEND_RECV_VARIADIC_SPEC_HANDLER
  12. ZEND_NEW_SPEC_HANDLER
  13. ZEND_BEGIN_SILENCE_SPEC_HANDLER
  14. ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER
  15. ZEND_EXT_STMT_SPEC_HANDLER
  16. ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER
  17. ZEND_EXT_FCALL_END_SPEC_HANDLER
  18. ZEND_DECLARE_CLASS_SPEC_HANDLER
  19. ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER
  20. ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER
  21. ZEND_DECLARE_FUNCTION_SPEC_HANDLER
  22. ZEND_TICKS_SPEC_HANDLER
  23. ZEND_EXT_NOP_SPEC_HANDLER
  24. ZEND_NOP_SPEC_HANDLER
  25. ZEND_ADD_TRAIT_SPEC_HANDLER
  26. ZEND_BIND_TRAITS_SPEC_HANDLER
  27. ZEND_HANDLE_EXCEPTION_SPEC_HANDLER
  28. ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER
  29. ZEND_USER_OPCODE_SPEC_HANDLER
  30. ZEND_DISCARD_EXCEPTION_SPEC_HANDLER
  31. ZEND_FAST_CALL_SPEC_HANDLER
  32. ZEND_FAST_RET_SPEC_HANDLER
  33. ZEND_FETCH_CLASS_SPEC_CONST_HANDLER
  34. ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER
  35. ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER
  36. ZEND_RECV_INIT_SPEC_CONST_HANDLER
  37. ZEND_BRK_SPEC_CONST_HANDLER
  38. ZEND_CONT_SPEC_CONST_HANDLER
  39. ZEND_GOTO_SPEC_CONST_HANDLER
  40. ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER
  41. ZEND_FETCH_CLASS_SPEC_TMP_HANDLER
  42. ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER
  43. ZEND_FETCH_CLASS_SPEC_VAR_HANDLER
  44. ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER
  45. ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER
  46. ZEND_FETCH_CLASS_SPEC_CV_HANDLER
  47. ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER
  48. ZEND_BW_NOT_SPEC_CONST_HANDLER
  49. ZEND_BOOL_NOT_SPEC_CONST_HANDLER
  50. ZEND_ECHO_SPEC_CONST_HANDLER
  51. ZEND_PRINT_SPEC_CONST_HANDLER
  52. ZEND_JMPZ_SPEC_CONST_HANDLER
  53. ZEND_JMPNZ_SPEC_CONST_HANDLER
  54. ZEND_JMPZNZ_SPEC_CONST_HANDLER
  55. ZEND_JMPZ_EX_SPEC_CONST_HANDLER
  56. ZEND_JMPNZ_EX_SPEC_CONST_HANDLER
  57. ZEND_DO_FCALL_SPEC_CONST_HANDLER
  58. ZEND_RETURN_SPEC_CONST_HANDLER
  59. ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER
  60. ZEND_THROW_SPEC_CONST_HANDLER
  61. ZEND_SEND_VAL_SPEC_CONST_HANDLER
  62. ZEND_BOOL_SPEC_CONST_HANDLER
  63. ZEND_CLONE_SPEC_CONST_HANDLER
  64. ZEND_CAST_SPEC_CONST_HANDLER
  65. ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER
  66. ZEND_FE_RESET_SPEC_CONST_HANDLER
  67. ZEND_EXIT_SPEC_CONST_HANDLER
  68. ZEND_JMP_SET_SPEC_CONST_HANDLER
  69. ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER
  70. ZEND_QM_ASSIGN_SPEC_CONST_HANDLER
  71. ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER
  72. ZEND_ADD_SPEC_CONST_CONST_HANDLER
  73. ZEND_SUB_SPEC_CONST_CONST_HANDLER
  74. ZEND_MUL_SPEC_CONST_CONST_HANDLER
  75. ZEND_DIV_SPEC_CONST_CONST_HANDLER
  76. ZEND_MOD_SPEC_CONST_CONST_HANDLER
  77. ZEND_SL_SPEC_CONST_CONST_HANDLER
  78. ZEND_SR_SPEC_CONST_CONST_HANDLER
  79. ZEND_CONCAT_SPEC_CONST_CONST_HANDLER
  80. ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER
  81. ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER
  82. ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER
  83. ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER
  84. ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER
  85. ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER
  86. ZEND_BW_OR_SPEC_CONST_CONST_HANDLER
  87. ZEND_BW_AND_SPEC_CONST_CONST_HANDLER
  88. ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER
  89. ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER
  90. zend_fetch_var_address_helper_SPEC_CONST_CONST
  91. ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER
  92. ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER
  93. ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER
  94. ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER
  95. ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER
  96. ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER
  97. ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER
  98. ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER
  99. ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER
  100. ZEND_CASE_SPEC_CONST_CONST_HANDLER
  101. ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER
  102. ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER
  103. ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER
  104. ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER
  105. ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER
  106. ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER
  107. ZEND_YIELD_SPEC_CONST_CONST_HANDLER
  108. ZEND_POW_SPEC_CONST_CONST_HANDLER
  109. ZEND_ADD_SPEC_CONST_TMP_HANDLER
  110. ZEND_SUB_SPEC_CONST_TMP_HANDLER
  111. ZEND_MUL_SPEC_CONST_TMP_HANDLER
  112. ZEND_DIV_SPEC_CONST_TMP_HANDLER
  113. ZEND_MOD_SPEC_CONST_TMP_HANDLER
  114. ZEND_SL_SPEC_CONST_TMP_HANDLER
  115. ZEND_SR_SPEC_CONST_TMP_HANDLER
  116. ZEND_CONCAT_SPEC_CONST_TMP_HANDLER
  117. ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER
  118. ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER
  119. ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER
  120. ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER
  121. ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER
  122. ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER
  123. ZEND_BW_OR_SPEC_CONST_TMP_HANDLER
  124. ZEND_BW_AND_SPEC_CONST_TMP_HANDLER
  125. ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER
  126. ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER
  127. ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER
  128. ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER
  129. ZEND_CASE_SPEC_CONST_TMP_HANDLER
  130. ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER
  131. ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER
  132. ZEND_YIELD_SPEC_CONST_TMP_HANDLER
  133. ZEND_POW_SPEC_CONST_TMP_HANDLER
  134. ZEND_ADD_SPEC_CONST_VAR_HANDLER
  135. ZEND_SUB_SPEC_CONST_VAR_HANDLER
  136. ZEND_MUL_SPEC_CONST_VAR_HANDLER
  137. ZEND_DIV_SPEC_CONST_VAR_HANDLER
  138. ZEND_MOD_SPEC_CONST_VAR_HANDLER
  139. ZEND_SL_SPEC_CONST_VAR_HANDLER
  140. ZEND_SR_SPEC_CONST_VAR_HANDLER
  141. ZEND_CONCAT_SPEC_CONST_VAR_HANDLER
  142. ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER
  143. ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER
  144. ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER
  145. ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER
  146. ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER
  147. ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER
  148. ZEND_BW_OR_SPEC_CONST_VAR_HANDLER
  149. ZEND_BW_AND_SPEC_CONST_VAR_HANDLER
  150. ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER
  151. ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER
  152. zend_fetch_var_address_helper_SPEC_CONST_VAR
  153. ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER
  154. ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER
  155. ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER
  156. ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER
  157. ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER
  158. ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER
  159. ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER
  160. ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER
  161. ZEND_CASE_SPEC_CONST_VAR_HANDLER
  162. ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER
  163. ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER
  164. ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER
  165. ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER
  166. ZEND_YIELD_SPEC_CONST_VAR_HANDLER
  167. ZEND_POW_SPEC_CONST_VAR_HANDLER
  168. zend_fetch_var_address_helper_SPEC_CONST_UNUSED
  169. ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER
  170. ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER
  171. ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER
  172. ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER
  173. ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER
  174. ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER
  175. ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
  176. ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER
  177. ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER
  178. ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER
  179. ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER
  180. ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER
  181. ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER
  182. ZEND_ADD_SPEC_CONST_CV_HANDLER
  183. ZEND_SUB_SPEC_CONST_CV_HANDLER
  184. ZEND_MUL_SPEC_CONST_CV_HANDLER
  185. ZEND_DIV_SPEC_CONST_CV_HANDLER
  186. ZEND_MOD_SPEC_CONST_CV_HANDLER
  187. ZEND_SL_SPEC_CONST_CV_HANDLER
  188. ZEND_SR_SPEC_CONST_CV_HANDLER
  189. ZEND_CONCAT_SPEC_CONST_CV_HANDLER
  190. ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER
  191. ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER
  192. ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER
  193. ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER
  194. ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER
  195. ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER
  196. ZEND_BW_OR_SPEC_CONST_CV_HANDLER
  197. ZEND_BW_AND_SPEC_CONST_CV_HANDLER
  198. ZEND_BW_XOR_SPEC_CONST_CV_HANDLER
  199. ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER
  200. ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER
  201. ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER
  202. ZEND_CATCH_SPEC_CONST_CV_HANDLER
  203. ZEND_CASE_SPEC_CONST_CV_HANDLER
  204. ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER
  205. ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER
  206. ZEND_YIELD_SPEC_CONST_CV_HANDLER
  207. ZEND_POW_SPEC_CONST_CV_HANDLER
  208. ZEND_BW_NOT_SPEC_TMP_HANDLER
  209. ZEND_BOOL_NOT_SPEC_TMP_HANDLER
  210. ZEND_ECHO_SPEC_TMP_HANDLER
  211. ZEND_PRINT_SPEC_TMP_HANDLER
  212. ZEND_JMPZ_SPEC_TMP_HANDLER
  213. ZEND_JMPNZ_SPEC_TMP_HANDLER
  214. ZEND_JMPZNZ_SPEC_TMP_HANDLER
  215. ZEND_JMPZ_EX_SPEC_TMP_HANDLER
  216. ZEND_JMPNZ_EX_SPEC_TMP_HANDLER
  217. ZEND_FREE_SPEC_TMP_HANDLER
  218. ZEND_RETURN_SPEC_TMP_HANDLER
  219. ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER
  220. ZEND_THROW_SPEC_TMP_HANDLER
  221. ZEND_SEND_VAL_SPEC_TMP_HANDLER
  222. ZEND_BOOL_SPEC_TMP_HANDLER
  223. ZEND_CLONE_SPEC_TMP_HANDLER
  224. ZEND_CAST_SPEC_TMP_HANDLER
  225. ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER
  226. ZEND_FE_RESET_SPEC_TMP_HANDLER
  227. ZEND_EXIT_SPEC_TMP_HANDLER
  228. ZEND_END_SILENCE_SPEC_TMP_HANDLER
  229. ZEND_JMP_SET_SPEC_TMP_HANDLER
  230. ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER
  231. ZEND_QM_ASSIGN_SPEC_TMP_HANDLER
  232. ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER
  233. ZEND_INSTANCEOF_SPEC_TMP_HANDLER
  234. ZEND_ADD_SPEC_TMP_CONST_HANDLER
  235. ZEND_SUB_SPEC_TMP_CONST_HANDLER
  236. ZEND_MUL_SPEC_TMP_CONST_HANDLER
  237. ZEND_DIV_SPEC_TMP_CONST_HANDLER
  238. ZEND_MOD_SPEC_TMP_CONST_HANDLER
  239. ZEND_SL_SPEC_TMP_CONST_HANDLER
  240. ZEND_SR_SPEC_TMP_CONST_HANDLER
  241. ZEND_CONCAT_SPEC_TMP_CONST_HANDLER
  242. ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER
  243. ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER
  244. ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER
  245. ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER
  246. ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER
  247. ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER
  248. ZEND_BW_OR_SPEC_TMP_CONST_HANDLER
  249. ZEND_BW_AND_SPEC_TMP_CONST_HANDLER
  250. ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER
  251. ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER
  252. zend_fetch_var_address_helper_SPEC_TMP_CONST
  253. ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER
  254. ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER
  255. ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER
  256. ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER
  257. ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER
  258. ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER
  259. ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER
  260. ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER
  261. ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER
  262. ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER
  263. ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER
  264. ZEND_CASE_SPEC_TMP_CONST_HANDLER
  265. ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER
  266. ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER
  267. ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER
  268. ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER
  269. ZEND_YIELD_SPEC_TMP_CONST_HANDLER
  270. ZEND_POW_SPEC_TMP_CONST_HANDLER
  271. ZEND_ADD_SPEC_TMP_TMP_HANDLER
  272. ZEND_SUB_SPEC_TMP_TMP_HANDLER
  273. ZEND_MUL_SPEC_TMP_TMP_HANDLER
  274. ZEND_DIV_SPEC_TMP_TMP_HANDLER
  275. ZEND_MOD_SPEC_TMP_TMP_HANDLER
  276. ZEND_SL_SPEC_TMP_TMP_HANDLER
  277. ZEND_SR_SPEC_TMP_TMP_HANDLER
  278. ZEND_CONCAT_SPEC_TMP_TMP_HANDLER
  279. ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER
  280. ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER
  281. ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER
  282. ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER
  283. ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER
  284. ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER
  285. ZEND_BW_OR_SPEC_TMP_TMP_HANDLER
  286. ZEND_BW_AND_SPEC_TMP_TMP_HANDLER
  287. ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER
  288. ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER
  289. ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER
  290. ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER
  291. ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER
  292. ZEND_CASE_SPEC_TMP_TMP_HANDLER
  293. ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER
  294. ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER
  295. ZEND_YIELD_SPEC_TMP_TMP_HANDLER
  296. ZEND_POW_SPEC_TMP_TMP_HANDLER
  297. ZEND_ADD_SPEC_TMP_VAR_HANDLER
  298. ZEND_SUB_SPEC_TMP_VAR_HANDLER
  299. ZEND_MUL_SPEC_TMP_VAR_HANDLER
  300. ZEND_DIV_SPEC_TMP_VAR_HANDLER
  301. ZEND_MOD_SPEC_TMP_VAR_HANDLER
  302. ZEND_SL_SPEC_TMP_VAR_HANDLER
  303. ZEND_SR_SPEC_TMP_VAR_HANDLER
  304. ZEND_CONCAT_SPEC_TMP_VAR_HANDLER
  305. ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER
  306. ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER
  307. ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER
  308. ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER
  309. ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER
  310. ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER
  311. ZEND_BW_OR_SPEC_TMP_VAR_HANDLER
  312. ZEND_BW_AND_SPEC_TMP_VAR_HANDLER
  313. ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER
  314. ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER
  315. zend_fetch_var_address_helper_SPEC_TMP_VAR
  316. ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER
  317. ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER
  318. ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER
  319. ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER
  320. ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER
  321. ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER
  322. ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER
  323. ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER
  324. ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER
  325. ZEND_CASE_SPEC_TMP_VAR_HANDLER
  326. ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER
  327. ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER
  328. ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER
  329. ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER
  330. ZEND_YIELD_SPEC_TMP_VAR_HANDLER
  331. ZEND_POW_SPEC_TMP_VAR_HANDLER
  332. zend_fetch_var_address_helper_SPEC_TMP_UNUSED
  333. ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER
  334. ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER
  335. ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER
  336. ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER
  337. ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER
  338. ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER
  339. ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER
  340. ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER
  341. ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER
  342. ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER
  343. ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER
  344. ZEND_ADD_SPEC_TMP_CV_HANDLER
  345. ZEND_SUB_SPEC_TMP_CV_HANDLER
  346. ZEND_MUL_SPEC_TMP_CV_HANDLER
  347. ZEND_DIV_SPEC_TMP_CV_HANDLER
  348. ZEND_MOD_SPEC_TMP_CV_HANDLER
  349. ZEND_SL_SPEC_TMP_CV_HANDLER
  350. ZEND_SR_SPEC_TMP_CV_HANDLER
  351. ZEND_CONCAT_SPEC_TMP_CV_HANDLER
  352. ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER
  353. ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER
  354. ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER
  355. ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER
  356. ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER
  357. ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER
  358. ZEND_BW_OR_SPEC_TMP_CV_HANDLER
  359. ZEND_BW_AND_SPEC_TMP_CV_HANDLER
  360. ZEND_BW_XOR_SPEC_TMP_CV_HANDLER
  361. ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER
  362. ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER
  363. ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER
  364. ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER
  365. ZEND_CASE_SPEC_TMP_CV_HANDLER
  366. ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER
  367. ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER
  368. ZEND_YIELD_SPEC_TMP_CV_HANDLER
  369. ZEND_POW_SPEC_TMP_CV_HANDLER
  370. ZEND_BW_NOT_SPEC_VAR_HANDLER
  371. ZEND_BOOL_NOT_SPEC_VAR_HANDLER
  372. ZEND_PRE_INC_SPEC_VAR_HANDLER
  373. ZEND_PRE_DEC_SPEC_VAR_HANDLER
  374. ZEND_POST_INC_SPEC_VAR_HANDLER
  375. ZEND_POST_DEC_SPEC_VAR_HANDLER
  376. ZEND_ECHO_SPEC_VAR_HANDLER
  377. ZEND_PRINT_SPEC_VAR_HANDLER
  378. ZEND_JMPZ_SPEC_VAR_HANDLER
  379. ZEND_JMPNZ_SPEC_VAR_HANDLER
  380. ZEND_JMPZNZ_SPEC_VAR_HANDLER
  381. ZEND_JMPZ_EX_SPEC_VAR_HANDLER
  382. ZEND_JMPNZ_EX_SPEC_VAR_HANDLER
  383. ZEND_FREE_SPEC_VAR_HANDLER
  384. ZEND_RETURN_SPEC_VAR_HANDLER
  385. ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER
  386. ZEND_THROW_SPEC_VAR_HANDLER
  387. zend_send_by_var_helper_SPEC_VAR
  388. ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER
  389. ZEND_SEND_REF_SPEC_VAR_HANDLER
  390. ZEND_SEND_VAR_SPEC_VAR_HANDLER
  391. ZEND_BOOL_SPEC_VAR_HANDLER
  392. ZEND_SWITCH_FREE_SPEC_VAR_HANDLER
  393. ZEND_CLONE_SPEC_VAR_HANDLER
  394. ZEND_CAST_SPEC_VAR_HANDLER
  395. ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER
  396. ZEND_FE_RESET_SPEC_VAR_HANDLER
  397. ZEND_FE_FETCH_SPEC_VAR_HANDLER
  398. ZEND_EXIT_SPEC_VAR_HANDLER
  399. ZEND_JMP_SET_SPEC_VAR_HANDLER
  400. ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER
  401. ZEND_QM_ASSIGN_SPEC_VAR_HANDLER
  402. ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER
  403. ZEND_INSTANCEOF_SPEC_VAR_HANDLER
  404. ZEND_ADD_SPEC_VAR_CONST_HANDLER
  405. ZEND_SUB_SPEC_VAR_CONST_HANDLER
  406. ZEND_MUL_SPEC_VAR_CONST_HANDLER
  407. ZEND_DIV_SPEC_VAR_CONST_HANDLER
  408. ZEND_MOD_SPEC_VAR_CONST_HANDLER
  409. ZEND_SL_SPEC_VAR_CONST_HANDLER
  410. ZEND_SR_SPEC_VAR_CONST_HANDLER
  411. ZEND_CONCAT_SPEC_VAR_CONST_HANDLER
  412. ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER
  413. ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER
  414. ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER
  415. ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER
  416. ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER
  417. ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER
  418. ZEND_BW_OR_SPEC_VAR_CONST_HANDLER
  419. ZEND_BW_AND_SPEC_VAR_CONST_HANDLER
  420. ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER
  421. ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER
  422. zend_binary_assign_op_obj_helper_SPEC_VAR_CONST
  423. zend_binary_assign_op_helper_SPEC_VAR_CONST
  424. ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER
  425. ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER
  426. ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER
  427. ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER
  428. ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER
  429. ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER
  430. ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER
  431. ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER
  432. ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER
  433. ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER
  434. ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER
  435. zend_pre_incdec_property_helper_SPEC_VAR_CONST
  436. ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER
  437. ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER
  438. zend_post_incdec_property_helper_SPEC_VAR_CONST
  439. ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER
  440. ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER
  441. zend_fetch_var_address_helper_SPEC_VAR_CONST
  442. ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER
  443. ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER
  444. ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER
  445. ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER
  446. ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER
  447. ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER
  448. ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER
  449. ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER
  450. ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER
  451. ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER
  452. ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER
  453. ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER
  454. zend_fetch_property_address_read_helper_SPEC_VAR_CONST
  455. ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER
  456. ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER
  457. ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER
  458. ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER
  459. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER
  460. ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER
  461. ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER
  462. ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER
  463. ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER
  464. ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER
  465. ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER
  466. ZEND_CASE_SPEC_VAR_CONST_HANDLER
  467. ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER
  468. ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER
  469. ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER
  470. ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER
  471. ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER
  472. ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER
  473. ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER
  474. zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST
  475. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER
  476. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER
  477. ZEND_YIELD_SPEC_VAR_CONST_HANDLER
  478. ZEND_POW_SPEC_VAR_CONST_HANDLER
  479. ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER
  480. ZEND_ADD_SPEC_VAR_TMP_HANDLER
  481. ZEND_SUB_SPEC_VAR_TMP_HANDLER
  482. ZEND_MUL_SPEC_VAR_TMP_HANDLER
  483. ZEND_DIV_SPEC_VAR_TMP_HANDLER
  484. ZEND_MOD_SPEC_VAR_TMP_HANDLER
  485. ZEND_SL_SPEC_VAR_TMP_HANDLER
  486. ZEND_SR_SPEC_VAR_TMP_HANDLER
  487. ZEND_CONCAT_SPEC_VAR_TMP_HANDLER
  488. ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER
  489. ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER
  490. ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER
  491. ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER
  492. ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER
  493. ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER
  494. ZEND_BW_OR_SPEC_VAR_TMP_HANDLER
  495. ZEND_BW_AND_SPEC_VAR_TMP_HANDLER
  496. ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER
  497. ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER
  498. zend_binary_assign_op_obj_helper_SPEC_VAR_TMP
  499. zend_binary_assign_op_helper_SPEC_VAR_TMP
  500. ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER
  501. ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER
  502. ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER
  503. ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER
  504. ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER
  505. ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER
  506. ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER
  507. ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER
  508. ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER
  509. ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER
  510. ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER
  511. zend_pre_incdec_property_helper_SPEC_VAR_TMP
  512. ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER
  513. ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER
  514. zend_post_incdec_property_helper_SPEC_VAR_TMP
  515. ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER
  516. ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER
  517. ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER
  518. ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER
  519. ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER
  520. ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER
  521. ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER
  522. ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER
  523. zend_fetch_property_address_read_helper_SPEC_VAR_TMP
  524. ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER
  525. ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER
  526. ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER
  527. ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER
  528. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER
  529. ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER
  530. ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER
  531. ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER
  532. ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER
  533. ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER
  534. ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER
  535. ZEND_CASE_SPEC_VAR_TMP_HANDLER
  536. ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER
  537. ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER
  538. ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER
  539. ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER
  540. zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP
  541. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER
  542. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER
  543. ZEND_YIELD_SPEC_VAR_TMP_HANDLER
  544. ZEND_POW_SPEC_VAR_TMP_HANDLER
  545. ZEND_ASSIGN_POW_SPEC_VAR_TMP_HANDLER
  546. ZEND_ADD_SPEC_VAR_VAR_HANDLER
  547. ZEND_SUB_SPEC_VAR_VAR_HANDLER
  548. ZEND_MUL_SPEC_VAR_VAR_HANDLER
  549. ZEND_DIV_SPEC_VAR_VAR_HANDLER
  550. ZEND_MOD_SPEC_VAR_VAR_HANDLER
  551. ZEND_SL_SPEC_VAR_VAR_HANDLER
  552. ZEND_SR_SPEC_VAR_VAR_HANDLER
  553. ZEND_CONCAT_SPEC_VAR_VAR_HANDLER
  554. ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER
  555. ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER
  556. ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER
  557. ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER
  558. ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER
  559. ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER
  560. ZEND_BW_OR_SPEC_VAR_VAR_HANDLER
  561. ZEND_BW_AND_SPEC_VAR_VAR_HANDLER
  562. ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER
  563. ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER
  564. zend_binary_assign_op_obj_helper_SPEC_VAR_VAR
  565. zend_binary_assign_op_helper_SPEC_VAR_VAR
  566. ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER
  567. ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER
  568. ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER
  569. ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER
  570. ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER
  571. ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER
  572. ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER
  573. ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER
  574. ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER
  575. ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER
  576. ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER
  577. zend_pre_incdec_property_helper_SPEC_VAR_VAR
  578. ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER
  579. ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER
  580. zend_post_incdec_property_helper_SPEC_VAR_VAR
  581. ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER
  582. ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER
  583. zend_fetch_var_address_helper_SPEC_VAR_VAR
  584. ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER
  585. ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER
  586. ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER
  587. ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER
  588. ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER
  589. ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER
  590. ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER
  591. ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER
  592. ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER
  593. ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER
  594. ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER
  595. ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER
  596. zend_fetch_property_address_read_helper_SPEC_VAR_VAR
  597. ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER
  598. ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER
  599. ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER
  600. ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER
  601. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER
  602. ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER
  603. ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER
  604. ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER
  605. ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER
  606. ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER
  607. ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER
  608. ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER
  609. ZEND_CASE_SPEC_VAR_VAR_HANDLER
  610. ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER
  611. ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER
  612. ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER
  613. ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER
  614. ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER
  615. ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER
  616. zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR
  617. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER
  618. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER
  619. ZEND_YIELD_SPEC_VAR_VAR_HANDLER
  620. ZEND_POW_SPEC_VAR_VAR_HANDLER
  621. ZEND_ASSIGN_POW_SPEC_VAR_VAR_HANDLER
  622. zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED
  623. zend_binary_assign_op_helper_SPEC_VAR_UNUSED
  624. ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER
  625. ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER
  626. ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER
  627. ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER
  628. ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER
  629. ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER
  630. ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER
  631. ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER
  632. ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER
  633. ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER
  634. ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER
  635. zend_fetch_var_address_helper_SPEC_VAR_UNUSED
  636. ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER
  637. ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER
  638. ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER
  639. ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER
  640. ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER
  641. ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER
  642. ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER
  643. ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER
  644. ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER
  645. ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER
  646. ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER
  647. ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER
  648. ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER
  649. ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER
  650. ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER
  651. ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER
  652. ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER
  653. ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_HANDLER
  654. ZEND_ADD_SPEC_VAR_CV_HANDLER
  655. ZEND_SUB_SPEC_VAR_CV_HANDLER
  656. ZEND_MUL_SPEC_VAR_CV_HANDLER
  657. ZEND_DIV_SPEC_VAR_CV_HANDLER
  658. ZEND_MOD_SPEC_VAR_CV_HANDLER
  659. ZEND_SL_SPEC_VAR_CV_HANDLER
  660. ZEND_SR_SPEC_VAR_CV_HANDLER
  661. ZEND_CONCAT_SPEC_VAR_CV_HANDLER
  662. ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER
  663. ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER
  664. ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER
  665. ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER
  666. ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER
  667. ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER
  668. ZEND_BW_OR_SPEC_VAR_CV_HANDLER
  669. ZEND_BW_AND_SPEC_VAR_CV_HANDLER
  670. ZEND_BW_XOR_SPEC_VAR_CV_HANDLER
  671. ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER
  672. zend_binary_assign_op_obj_helper_SPEC_VAR_CV
  673. zend_binary_assign_op_helper_SPEC_VAR_CV
  674. ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER
  675. ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER
  676. ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER
  677. ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER
  678. ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER
  679. ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER
  680. ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER
  681. ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER
  682. ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER
  683. ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER
  684. ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER
  685. zend_pre_incdec_property_helper_SPEC_VAR_CV
  686. ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER
  687. ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER
  688. zend_post_incdec_property_helper_SPEC_VAR_CV
  689. ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER
  690. ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER
  691. ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER
  692. ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER
  693. ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER
  694. ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER
  695. ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER
  696. ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER
  697. zend_fetch_property_address_read_helper_SPEC_VAR_CV
  698. ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER
  699. ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER
  700. ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER
  701. ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER
  702. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER
  703. ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER
  704. ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER
  705. ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER
  706. ZEND_ASSIGN_SPEC_VAR_CV_HANDLER
  707. ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER
  708. ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER
  709. ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER
  710. ZEND_CASE_SPEC_VAR_CV_HANDLER
  711. ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER
  712. ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER
  713. ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER
  714. ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER
  715. zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV
  716. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER
  717. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER
  718. ZEND_YIELD_SPEC_VAR_CV_HANDLER
  719. ZEND_POW_SPEC_VAR_CV_HANDLER
  720. ZEND_ASSIGN_POW_SPEC_VAR_CV_HANDLER
  721. ZEND_CLONE_SPEC_UNUSED_HANDLER
  722. ZEND_EXIT_SPEC_UNUSED_HANDLER
  723. zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST
  724. zend_binary_assign_op_helper_SPEC_UNUSED_CONST
  725. ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER
  726. ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER
  727. ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER
  728. ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER
  729. ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER
  730. ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER
  731. ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER
  732. ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER
  733. ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER
  734. ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER
  735. ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER
  736. zend_pre_incdec_property_helper_SPEC_UNUSED_CONST
  737. ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER
  738. ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER
  739. zend_post_incdec_property_helper_SPEC_UNUSED_CONST
  740. ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER
  741. ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER
  742. zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST
  743. ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER
  744. ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER
  745. ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER
  746. ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER
  747. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER
  748. ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER
  749. ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER
  750. ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER
  751. ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER
  752. ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER
  753. ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER
  754. ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER
  755. ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER
  756. ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER
  757. zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST
  758. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER
  759. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER
  760. ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER
  761. ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_HANDLER
  762. zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP
  763. zend_binary_assign_op_helper_SPEC_UNUSED_TMP
  764. ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER
  765. ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER
  766. ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER
  767. ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER
  768. ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER
  769. ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER
  770. ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER
  771. ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER
  772. ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER
  773. ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER
  774. ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER
  775. zend_pre_incdec_property_helper_SPEC_UNUSED_TMP
  776. ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER
  777. ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER
  778. zend_post_incdec_property_helper_SPEC_UNUSED_TMP
  779. ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER
  780. ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER
  781. zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP
  782. ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER
  783. ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER
  784. ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER
  785. ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER
  786. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER
  787. ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER
  788. ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER
  789. ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER
  790. ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER
  791. ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER
  792. ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER
  793. ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER
  794. zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP
  795. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER
  796. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER
  797. ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER
  798. ZEND_ASSIGN_POW_SPEC_UNUSED_TMP_HANDLER
  799. zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR
  800. zend_binary_assign_op_helper_SPEC_UNUSED_VAR
  801. ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER
  802. ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER
  803. ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER
  804. ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER
  805. ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER
  806. ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER
  807. ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER
  808. ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER
  809. ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER
  810. ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER
  811. ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER
  812. zend_pre_incdec_property_helper_SPEC_UNUSED_VAR
  813. ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER
  814. ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER
  815. zend_post_incdec_property_helper_SPEC_UNUSED_VAR
  816. ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER
  817. ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER
  818. zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR
  819. ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER
  820. ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER
  821. ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER
  822. ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER
  823. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER
  824. ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER
  825. ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER
  826. ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER
  827. ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER
  828. ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER
  829. ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER
  830. ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER
  831. zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR
  832. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER
  833. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER
  834. ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER
  835. ZEND_ASSIGN_POW_SPEC_UNUSED_VAR_HANDLER
  836. zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED
  837. zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED
  838. ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER
  839. ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER
  840. ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER
  841. ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER
  842. ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER
  843. ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER
  844. ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER
  845. ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER
  846. ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER
  847. ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER
  848. ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER
  849. ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER
  850. ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER
  851. ZEND_ASSIGN_POW_SPEC_UNUSED_UNUSED_HANDLER
  852. zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV
  853. zend_binary_assign_op_helper_SPEC_UNUSED_CV
  854. ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER
  855. ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER
  856. ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER
  857. ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER
  858. ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER
  859. ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER
  860. ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER
  861. ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER
  862. ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER
  863. ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER
  864. ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER
  865. zend_pre_incdec_property_helper_SPEC_UNUSED_CV
  866. ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER
  867. ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER
  868. zend_post_incdec_property_helper_SPEC_UNUSED_CV
  869. ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER
  870. ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER
  871. zend_fetch_property_address_read_helper_SPEC_UNUSED_CV
  872. ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER
  873. ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER
  874. ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER
  875. ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER
  876. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER
  877. ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER
  878. ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER
  879. ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER
  880. ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER
  881. ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER
  882. ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER
  883. ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER
  884. zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV
  885. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER
  886. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER
  887. ZEND_YIELD_SPEC_UNUSED_CV_HANDLER
  888. ZEND_ASSIGN_POW_SPEC_UNUSED_CV_HANDLER
  889. ZEND_BW_NOT_SPEC_CV_HANDLER
  890. ZEND_BOOL_NOT_SPEC_CV_HANDLER
  891. ZEND_PRE_INC_SPEC_CV_HANDLER
  892. ZEND_PRE_DEC_SPEC_CV_HANDLER
  893. ZEND_POST_INC_SPEC_CV_HANDLER
  894. ZEND_POST_DEC_SPEC_CV_HANDLER
  895. ZEND_ECHO_SPEC_CV_HANDLER
  896. ZEND_PRINT_SPEC_CV_HANDLER
  897. ZEND_JMPZ_SPEC_CV_HANDLER
  898. ZEND_JMPNZ_SPEC_CV_HANDLER
  899. ZEND_JMPZNZ_SPEC_CV_HANDLER
  900. ZEND_JMPZ_EX_SPEC_CV_HANDLER
  901. ZEND_JMPNZ_EX_SPEC_CV_HANDLER
  902. ZEND_RETURN_SPEC_CV_HANDLER
  903. ZEND_RETURN_BY_REF_SPEC_CV_HANDLER
  904. ZEND_THROW_SPEC_CV_HANDLER
  905. zend_send_by_var_helper_SPEC_CV
  906. ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER
  907. ZEND_SEND_REF_SPEC_CV_HANDLER
  908. ZEND_SEND_VAR_SPEC_CV_HANDLER
  909. ZEND_BOOL_SPEC_CV_HANDLER
  910. ZEND_CLONE_SPEC_CV_HANDLER
  911. ZEND_CAST_SPEC_CV_HANDLER
  912. ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER
  913. ZEND_FE_RESET_SPEC_CV_HANDLER
  914. ZEND_EXIT_SPEC_CV_HANDLER
  915. ZEND_JMP_SET_SPEC_CV_HANDLER
  916. ZEND_JMP_SET_VAR_SPEC_CV_HANDLER
  917. ZEND_QM_ASSIGN_SPEC_CV_HANDLER
  918. ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER
  919. ZEND_INSTANCEOF_SPEC_CV_HANDLER
  920. ZEND_ADD_SPEC_CV_CONST_HANDLER
  921. ZEND_SUB_SPEC_CV_CONST_HANDLER
  922. ZEND_MUL_SPEC_CV_CONST_HANDLER
  923. ZEND_DIV_SPEC_CV_CONST_HANDLER
  924. ZEND_MOD_SPEC_CV_CONST_HANDLER
  925. ZEND_SL_SPEC_CV_CONST_HANDLER
  926. ZEND_SR_SPEC_CV_CONST_HANDLER
  927. ZEND_CONCAT_SPEC_CV_CONST_HANDLER
  928. ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER
  929. ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER
  930. ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER
  931. ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER
  932. ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER
  933. ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER
  934. ZEND_BW_OR_SPEC_CV_CONST_HANDLER
  935. ZEND_BW_AND_SPEC_CV_CONST_HANDLER
  936. ZEND_BW_XOR_SPEC_CV_CONST_HANDLER
  937. ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER
  938. zend_binary_assign_op_obj_helper_SPEC_CV_CONST
  939. zend_binary_assign_op_helper_SPEC_CV_CONST
  940. ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER
  941. ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER
  942. ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER
  943. ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER
  944. ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER
  945. ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER
  946. ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER
  947. ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER
  948. ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER
  949. ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER
  950. ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER
  951. zend_pre_incdec_property_helper_SPEC_CV_CONST
  952. ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER
  953. ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER
  954. zend_post_incdec_property_helper_SPEC_CV_CONST
  955. ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER
  956. ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER
  957. zend_fetch_var_address_helper_SPEC_CV_CONST
  958. ZEND_FETCH_R_SPEC_CV_CONST_HANDLER
  959. ZEND_FETCH_W_SPEC_CV_CONST_HANDLER
  960. ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER
  961. ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER
  962. ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER
  963. ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER
  964. ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER
  965. ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER
  966. ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER
  967. ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER
  968. ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER
  969. ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER
  970. zend_fetch_property_address_read_helper_SPEC_CV_CONST
  971. ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER
  972. ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER
  973. ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER
  974. ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER
  975. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER
  976. ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER
  977. ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER
  978. ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER
  979. ZEND_ASSIGN_SPEC_CV_CONST_HANDLER
  980. ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER
  981. ZEND_CASE_SPEC_CV_CONST_HANDLER
  982. ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER
  983. ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER
  984. ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER
  985. ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER
  986. ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER
  987. ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER
  988. zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST
  989. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER
  990. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER
  991. ZEND_YIELD_SPEC_CV_CONST_HANDLER
  992. ZEND_POW_SPEC_CV_CONST_HANDLER
  993. ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER
  994. ZEND_ADD_SPEC_CV_TMP_HANDLER
  995. ZEND_SUB_SPEC_CV_TMP_HANDLER
  996. ZEND_MUL_SPEC_CV_TMP_HANDLER
  997. ZEND_DIV_SPEC_CV_TMP_HANDLER
  998. ZEND_MOD_SPEC_CV_TMP_HANDLER
  999. ZEND_SL_SPEC_CV_TMP_HANDLER
  1000. ZEND_SR_SPEC_CV_TMP_HANDLER
  1001. ZEND_CONCAT_SPEC_CV_TMP_HANDLER
  1002. ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER
  1003. ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER
  1004. ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER
  1005. ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER
  1006. ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER
  1007. ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER
  1008. ZEND_BW_OR_SPEC_CV_TMP_HANDLER
  1009. ZEND_BW_AND_SPEC_CV_TMP_HANDLER
  1010. ZEND_BW_XOR_SPEC_CV_TMP_HANDLER
  1011. ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER
  1012. zend_binary_assign_op_obj_helper_SPEC_CV_TMP
  1013. zend_binary_assign_op_helper_SPEC_CV_TMP
  1014. ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER
  1015. ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER
  1016. ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER
  1017. ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER
  1018. ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER
  1019. ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER
  1020. ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER
  1021. ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER
  1022. ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER
  1023. ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER
  1024. ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER
  1025. zend_pre_incdec_property_helper_SPEC_CV_TMP
  1026. ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER
  1027. ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER
  1028. zend_post_incdec_property_helper_SPEC_CV_TMP
  1029. ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER
  1030. ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER
  1031. ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER
  1032. ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER
  1033. ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER
  1034. ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER
  1035. ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER
  1036. ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER
  1037. zend_fetch_property_address_read_helper_SPEC_CV_TMP
  1038. ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER
  1039. ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER
  1040. ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER
  1041. ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER
  1042. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER
  1043. ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER
  1044. ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER
  1045. ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER
  1046. ZEND_ASSIGN_SPEC_CV_TMP_HANDLER
  1047. ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER
  1048. ZEND_CASE_SPEC_CV_TMP_HANDLER
  1049. ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER
  1050. ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER
  1051. ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER
  1052. ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER
  1053. zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP
  1054. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER
  1055. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER
  1056. ZEND_YIELD_SPEC_CV_TMP_HANDLER
  1057. ZEND_POW_SPEC_CV_TMP_HANDLER
  1058. ZEND_ASSIGN_POW_SPEC_CV_TMP_HANDLER
  1059. ZEND_ADD_SPEC_CV_VAR_HANDLER
  1060. ZEND_SUB_SPEC_CV_VAR_HANDLER
  1061. ZEND_MUL_SPEC_CV_VAR_HANDLER
  1062. ZEND_DIV_SPEC_CV_VAR_HANDLER
  1063. ZEND_MOD_SPEC_CV_VAR_HANDLER
  1064. ZEND_SL_SPEC_CV_VAR_HANDLER
  1065. ZEND_SR_SPEC_CV_VAR_HANDLER
  1066. ZEND_CONCAT_SPEC_CV_VAR_HANDLER
  1067. ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER
  1068. ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER
  1069. ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER
  1070. ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER
  1071. ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER
  1072. ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER
  1073. ZEND_BW_OR_SPEC_CV_VAR_HANDLER
  1074. ZEND_BW_AND_SPEC_CV_VAR_HANDLER
  1075. ZEND_BW_XOR_SPEC_CV_VAR_HANDLER
  1076. ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER
  1077. zend_binary_assign_op_obj_helper_SPEC_CV_VAR
  1078. zend_binary_assign_op_helper_SPEC_CV_VAR
  1079. ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER
  1080. ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER
  1081. ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER
  1082. ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER
  1083. ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER
  1084. ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER
  1085. ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER
  1086. ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER
  1087. ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER
  1088. ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER
  1089. ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER
  1090. zend_pre_incdec_property_helper_SPEC_CV_VAR
  1091. ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER
  1092. ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER
  1093. zend_post_incdec_property_helper_SPEC_CV_VAR
  1094. ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER
  1095. ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER
  1096. zend_fetch_var_address_helper_SPEC_CV_VAR
  1097. ZEND_FETCH_R_SPEC_CV_VAR_HANDLER
  1098. ZEND_FETCH_W_SPEC_CV_VAR_HANDLER
  1099. ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER
  1100. ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER
  1101. ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER
  1102. ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER
  1103. ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER
  1104. ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER
  1105. ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER
  1106. ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER
  1107. ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER
  1108. ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER
  1109. zend_fetch_property_address_read_helper_SPEC_CV_VAR
  1110. ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER
  1111. ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER
  1112. ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER
  1113. ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER
  1114. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER
  1115. ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER
  1116. ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER
  1117. ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER
  1118. ZEND_ASSIGN_SPEC_CV_VAR_HANDLER
  1119. ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER
  1120. ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER
  1121. ZEND_CASE_SPEC_CV_VAR_HANDLER
  1122. ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER
  1123. ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER
  1124. ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER
  1125. ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER
  1126. ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER
  1127. ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER
  1128. zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR
  1129. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER
  1130. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER
  1131. ZEND_YIELD_SPEC_CV_VAR_HANDLER
  1132. ZEND_POW_SPEC_CV_VAR_HANDLER
  1133. ZEND_ASSIGN_POW_SPEC_CV_VAR_HANDLER
  1134. zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED
  1135. zend_binary_assign_op_helper_SPEC_CV_UNUSED
  1136. ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER
  1137. ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER
  1138. ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER
  1139. ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER
  1140. ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER
  1141. ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER
  1142. ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER
  1143. ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER
  1144. ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER
  1145. ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER
  1146. ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER
  1147. zend_fetch_var_address_helper_SPEC_CV_UNUSED
  1148. ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER
  1149. ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER
  1150. ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER
  1151. ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER
  1152. ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER
  1153. ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER
  1154. ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER
  1155. ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER
  1156. ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER
  1157. ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER
  1158. ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER
  1159. ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER
  1160. ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER
  1161. ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER
  1162. ZEND_YIELD_SPEC_CV_UNUSED_HANDLER
  1163. ZEND_ASSIGN_POW_SPEC_CV_UNUSED_HANDLER
  1164. ZEND_ADD_SPEC_CV_CV_HANDLER
  1165. ZEND_SUB_SPEC_CV_CV_HANDLER
  1166. ZEND_MUL_SPEC_CV_CV_HANDLER
  1167. ZEND_DIV_SPEC_CV_CV_HANDLER
  1168. ZEND_MOD_SPEC_CV_CV_HANDLER
  1169. ZEND_SL_SPEC_CV_CV_HANDLER
  1170. ZEND_SR_SPEC_CV_CV_HANDLER
  1171. ZEND_CONCAT_SPEC_CV_CV_HANDLER
  1172. ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER
  1173. ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER
  1174. ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER
  1175. ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER
  1176. ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER
  1177. ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER
  1178. ZEND_BW_OR_SPEC_CV_CV_HANDLER
  1179. ZEND_BW_AND_SPEC_CV_CV_HANDLER
  1180. ZEND_BW_XOR_SPEC_CV_CV_HANDLER
  1181. ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER
  1182. zend_binary_assign_op_obj_helper_SPEC_CV_CV
  1183. zend_binary_assign_op_helper_SPEC_CV_CV
  1184. ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER
  1185. ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER
  1186. ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER
  1187. ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER
  1188. ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER
  1189. ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER
  1190. ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER
  1191. ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER
  1192. ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER
  1193. ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER
  1194. ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER
  1195. zend_pre_incdec_property_helper_SPEC_CV_CV
  1196. ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER
  1197. ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER
  1198. zend_post_incdec_property_helper_SPEC_CV_CV
  1199. ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER
  1200. ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER
  1201. ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER
  1202. ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER
  1203. ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER
  1204. ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER
  1205. ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER
  1206. ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER
  1207. zend_fetch_property_address_read_helper_SPEC_CV_CV
  1208. ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER
  1209. ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER
  1210. ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER
  1211. ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER
  1212. ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER
  1213. ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER
  1214. ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER
  1215. ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER
  1216. ZEND_ASSIGN_SPEC_CV_CV_HANDLER
  1217. ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER
  1218. ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER
  1219. ZEND_CASE_SPEC_CV_CV_HANDLER
  1220. ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER
  1221. ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER
  1222. ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER
  1223. ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER
  1224. zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV
  1225. ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER
  1226. ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER
  1227. ZEND_YIELD_SPEC_CV_CV_HANDLER
  1228. ZEND_POW_SPEC_CV_CV_HANDLER
  1229. ZEND_ASSIGN_POW_SPEC_CV_CV_HANDLER
  1230. ZEND_NULL_HANDLER
  1231. zend_init_opcodes_handlers
  1232. zend_vm_get_opcode_handler
  1233. zend_vm_set_opcode_handler
  1234. zend_do_fcall
   1 /*
   2    +----------------------------------------------------------------------+
   3    | Zend Engine                                                          |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 1998-2016 Zend Technologies Ltd. (http://www.zend.com) |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 2.00 of the Zend license,     |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.zend.com/license/2_00.txt.                                |
  11    | If you did not receive a copy of the Zend license and are unable to  |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@zend.com so we can mail you a copy immediately.              |
  14    +----------------------------------------------------------------------+
  15    | Authors: Andi Gutmans <andi@zend.com>                                |
  16    |          Zeev Suraski <zeev@zend.com>                                |
  17    |          Dmitry Stogov <dmitry@zend.com>                             |
  18    +----------------------------------------------------------------------+
  19 */
  20 
  21 #ifdef ZEND_WIN32
  22 # pragma warning(once : 4101)
  23 # pragma warning(once : 6235)
  24 # pragma warning(once : 6237)
  25 # pragma warning(once : 6239)
  26 # pragma warning(once : 6240)
  27 # pragma warning(once : 6285)
  28 # pragma warning(once : 6286)
  29 # pragma warning(once : 6326)
  30 #endif
  31 static user_opcode_handler_t zend_user_opcode_handlers[256] = {
  32         (user_opcode_handler_t)NULL,
  33         (user_opcode_handler_t)NULL,
  34         (user_opcode_handler_t)NULL,
  35         (user_opcode_handler_t)NULL,
  36         (user_opcode_handler_t)NULL,
  37         (user_opcode_handler_t)NULL,
  38         (user_opcode_handler_t)NULL,
  39         (user_opcode_handler_t)NULL,
  40         (user_opcode_handler_t)NULL,
  41         (user_opcode_handler_t)NULL,
  42         (user_opcode_handler_t)NULL,
  43         (user_opcode_handler_t)NULL,
  44         (user_opcode_handler_t)NULL,
  45         (user_opcode_handler_t)NULL,
  46         (user_opcode_handler_t)NULL,
  47         (user_opcode_handler_t)NULL,
  48         (user_opcode_handler_t)NULL,
  49         (user_opcode_handler_t)NULL,
  50         (user_opcode_handler_t)NULL,
  51         (user_opcode_handler_t)NULL,
  52         (user_opcode_handler_t)NULL,
  53         (user_opcode_handler_t)NULL,
  54         (user_opcode_handler_t)NULL,
  55         (user_opcode_handler_t)NULL,
  56         (user_opcode_handler_t)NULL,
  57         (user_opcode_handler_t)NULL,
  58         (user_opcode_handler_t)NULL,
  59         (user_opcode_handler_t)NULL,
  60         (user_opcode_handler_t)NULL,
  61         (user_opcode_handler_t)NULL,
  62         (user_opcode_handler_t)NULL,
  63         (user_opcode_handler_t)NULL,
  64         (user_opcode_handler_t)NULL,
  65         (user_opcode_handler_t)NULL,
  66         (user_opcode_handler_t)NULL,
  67         (user_opcode_handler_t)NULL,
  68         (user_opcode_handler_t)NULL,
  69         (user_opcode_handler_t)NULL,
  70         (user_opcode_handler_t)NULL,
  71         (user_opcode_handler_t)NULL,
  72         (user_opcode_handler_t)NULL,
  73         (user_opcode_handler_t)NULL,
  74         (user_opcode_handler_t)NULL,
  75         (user_opcode_handler_t)NULL,
  76         (user_opcode_handler_t)NULL,
  77         (user_opcode_handler_t)NULL,
  78         (user_opcode_handler_t)NULL,
  79         (user_opcode_handler_t)NULL,
  80         (user_opcode_handler_t)NULL,
  81         (user_opcode_handler_t)NULL,
  82         (user_opcode_handler_t)NULL,
  83         (user_opcode_handler_t)NULL,
  84         (user_opcode_handler_t)NULL,
  85         (user_opcode_handler_t)NULL,
  86         (user_opcode_handler_t)NULL,
  87         (user_opcode_handler_t)NULL,
  88         (user_opcode_handler_t)NULL,
  89         (user_opcode_handler_t)NULL,
  90         (user_opcode_handler_t)NULL,
  91         (user_opcode_handler_t)NULL,
  92         (user_opcode_handler_t)NULL,
  93         (user_opcode_handler_t)NULL,
  94         (user_opcode_handler_t)NULL,
  95         (user_opcode_handler_t)NULL,
  96         (user_opcode_handler_t)NULL,
  97         (user_opcode_handler_t)NULL,
  98         (user_opcode_handler_t)NULL,
  99         (user_opcode_handler_t)NULL,
 100         (user_opcode_handler_t)NULL,
 101         (user_opcode_handler_t)NULL,
 102         (user_opcode_handler_t)NULL,
 103         (user_opcode_handler_t)NULL,
 104         (user_opcode_handler_t)NULL,
 105         (user_opcode_handler_t)NULL,
 106         (user_opcode_handler_t)NULL,
 107         (user_opcode_handler_t)NULL,
 108         (user_opcode_handler_t)NULL,
 109         (user_opcode_handler_t)NULL,
 110         (user_opcode_handler_t)NULL,
 111         (user_opcode_handler_t)NULL,
 112         (user_opcode_handler_t)NULL,
 113         (user_opcode_handler_t)NULL,
 114         (user_opcode_handler_t)NULL,
 115         (user_opcode_handler_t)NULL,
 116         (user_opcode_handler_t)NULL,
 117         (user_opcode_handler_t)NULL,
 118         (user_opcode_handler_t)NULL,
 119         (user_opcode_handler_t)NULL,
 120         (user_opcode_handler_t)NULL,
 121         (user_opcode_handler_t)NULL,
 122         (user_opcode_handler_t)NULL,
 123         (user_opcode_handler_t)NULL,
 124         (user_opcode_handler_t)NULL,
 125         (user_opcode_handler_t)NULL,
 126         (user_opcode_handler_t)NULL,
 127         (user_opcode_handler_t)NULL,
 128         (user_opcode_handler_t)NULL,
 129         (user_opcode_handler_t)NULL,
 130         (user_opcode_handler_t)NULL,
 131         (user_opcode_handler_t)NULL,
 132         (user_opcode_handler_t)NULL,
 133         (user_opcode_handler_t)NULL,
 134         (user_opcode_handler_t)NULL,
 135         (user_opcode_handler_t)NULL,
 136         (user_opcode_handler_t)NULL,
 137         (user_opcode_handler_t)NULL,
 138         (user_opcode_handler_t)NULL,
 139         (user_opcode_handler_t)NULL,
 140         (user_opcode_handler_t)NULL,
 141         (user_opcode_handler_t)NULL,
 142         (user_opcode_handler_t)NULL,
 143         (user_opcode_handler_t)NULL,
 144         (user_opcode_handler_t)NULL,
 145         (user_opcode_handler_t)NULL,
 146         (user_opcode_handler_t)NULL,
 147         (user_opcode_handler_t)NULL,
 148         (user_opcode_handler_t)NULL,
 149         (user_opcode_handler_t)NULL,
 150         (user_opcode_handler_t)NULL,
 151         (user_opcode_handler_t)NULL,
 152         (user_opcode_handler_t)NULL,
 153         (user_opcode_handler_t)NULL,
 154         (user_opcode_handler_t)NULL,
 155         (user_opcode_handler_t)NULL,
 156         (user_opcode_handler_t)NULL,
 157         (user_opcode_handler_t)NULL,
 158         (user_opcode_handler_t)NULL,
 159         (user_opcode_handler_t)NULL,
 160         (user_opcode_handler_t)NULL,
 161         (user_opcode_handler_t)NULL,
 162         (user_opcode_handler_t)NULL,
 163         (user_opcode_handler_t)NULL,
 164         (user_opcode_handler_t)NULL,
 165         (user_opcode_handler_t)NULL,
 166         (user_opcode_handler_t)NULL,
 167         (user_opcode_handler_t)NULL,
 168         (user_opcode_handler_t)NULL,
 169         (user_opcode_handler_t)NULL,
 170         (user_opcode_handler_t)NULL,
 171         (user_opcode_handler_t)NULL,
 172         (user_opcode_handler_t)NULL,
 173         (user_opcode_handler_t)NULL,
 174         (user_opcode_handler_t)NULL,
 175         (user_opcode_handler_t)NULL,
 176         (user_opcode_handler_t)NULL,
 177         (user_opcode_handler_t)NULL,
 178         (user_opcode_handler_t)NULL,
 179         (user_opcode_handler_t)NULL,
 180         (user_opcode_handler_t)NULL,
 181         (user_opcode_handler_t)NULL,
 182         (user_opcode_handler_t)NULL,
 183         (user_opcode_handler_t)NULL,
 184         (user_opcode_handler_t)NULL,
 185         (user_opcode_handler_t)NULL,
 186         (user_opcode_handler_t)NULL,
 187         (user_opcode_handler_t)NULL,
 188         (user_opcode_handler_t)NULL,
 189         (user_opcode_handler_t)NULL,
 190         (user_opcode_handler_t)NULL,
 191         (user_opcode_handler_t)NULL,
 192         (user_opcode_handler_t)NULL,
 193         (user_opcode_handler_t)NULL,
 194         (user_opcode_handler_t)NULL,
 195         (user_opcode_handler_t)NULL,
 196         (user_opcode_handler_t)NULL,
 197         (user_opcode_handler_t)NULL,
 198         (user_opcode_handler_t)NULL,
 199         (user_opcode_handler_t)NULL,
 200         (user_opcode_handler_t)NULL,
 201         (user_opcode_handler_t)NULL,
 202         (user_opcode_handler_t)NULL,
 203         (user_opcode_handler_t)NULL,
 204         (user_opcode_handler_t)NULL,
 205         (user_opcode_handler_t)NULL,
 206         (user_opcode_handler_t)NULL,
 207         (user_opcode_handler_t)NULL,
 208         (user_opcode_handler_t)NULL,
 209         (user_opcode_handler_t)NULL,
 210         (user_opcode_handler_t)NULL,
 211         (user_opcode_handler_t)NULL,
 212         (user_opcode_handler_t)NULL,
 213         (user_opcode_handler_t)NULL,
 214         (user_opcode_handler_t)NULL,
 215         (user_opcode_handler_t)NULL,
 216         (user_opcode_handler_t)NULL,
 217         (user_opcode_handler_t)NULL,
 218         (user_opcode_handler_t)NULL,
 219         (user_opcode_handler_t)NULL,
 220         (user_opcode_handler_t)NULL,
 221         (user_opcode_handler_t)NULL,
 222         (user_opcode_handler_t)NULL,
 223         (user_opcode_handler_t)NULL,
 224         (user_opcode_handler_t)NULL,
 225         (user_opcode_handler_t)NULL,
 226         (user_opcode_handler_t)NULL,
 227         (user_opcode_handler_t)NULL,
 228         (user_opcode_handler_t)NULL,
 229         (user_opcode_handler_t)NULL,
 230         (user_opcode_handler_t)NULL,
 231         (user_opcode_handler_t)NULL,
 232         (user_opcode_handler_t)NULL,
 233         (user_opcode_handler_t)NULL,
 234         (user_opcode_handler_t)NULL,
 235         (user_opcode_handler_t)NULL,
 236         (user_opcode_handler_t)NULL,
 237         (user_opcode_handler_t)NULL,
 238         (user_opcode_handler_t)NULL,
 239         (user_opcode_handler_t)NULL,
 240         (user_opcode_handler_t)NULL,
 241         (user_opcode_handler_t)NULL,
 242         (user_opcode_handler_t)NULL,
 243         (user_opcode_handler_t)NULL,
 244         (user_opcode_handler_t)NULL,
 245         (user_opcode_handler_t)NULL,
 246         (user_opcode_handler_t)NULL,
 247         (user_opcode_handler_t)NULL,
 248         (user_opcode_handler_t)NULL,
 249         (user_opcode_handler_t)NULL,
 250         (user_opcode_handler_t)NULL,
 251         (user_opcode_handler_t)NULL,
 252         (user_opcode_handler_t)NULL,
 253         (user_opcode_handler_t)NULL,
 254         (user_opcode_handler_t)NULL,
 255         (user_opcode_handler_t)NULL,
 256         (user_opcode_handler_t)NULL,
 257         (user_opcode_handler_t)NULL,
 258         (user_opcode_handler_t)NULL,
 259         (user_opcode_handler_t)NULL,
 260         (user_opcode_handler_t)NULL,
 261         (user_opcode_handler_t)NULL,
 262         (user_opcode_handler_t)NULL,
 263         (user_opcode_handler_t)NULL,
 264         (user_opcode_handler_t)NULL,
 265         (user_opcode_handler_t)NULL,
 266         (user_opcode_handler_t)NULL,
 267         (user_opcode_handler_t)NULL,
 268         (user_opcode_handler_t)NULL,
 269         (user_opcode_handler_t)NULL,
 270         (user_opcode_handler_t)NULL,
 271         (user_opcode_handler_t)NULL,
 272         (user_opcode_handler_t)NULL,
 273         (user_opcode_handler_t)NULL,
 274         (user_opcode_handler_t)NULL,
 275         (user_opcode_handler_t)NULL,
 276         (user_opcode_handler_t)NULL,
 277         (user_opcode_handler_t)NULL,
 278         (user_opcode_handler_t)NULL,
 279         (user_opcode_handler_t)NULL,
 280         (user_opcode_handler_t)NULL,
 281         (user_opcode_handler_t)NULL,
 282         (user_opcode_handler_t)NULL,
 283         (user_opcode_handler_t)NULL,
 284         (user_opcode_handler_t)NULL,
 285         (user_opcode_handler_t)NULL,
 286         (user_opcode_handler_t)NULL,
 287         (user_opcode_handler_t)NULL
 288 };
 289 
 290 static zend_uchar zend_user_opcodes[256] = {0,
 291         1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
 292         17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
 293         33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,
 294         49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,
 295         65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,
 296         81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,
 297         97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
 298         113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,
 299         129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,
 300         145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,
 301         161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,
 302         177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,
 303         193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,
 304         209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,
 305         225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,
 306         241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
 307 };
 308 
 309 static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op);
 310 
 311 
 312 #undef OPLINE
 313 #undef DCL_OPLINE
 314 #undef USE_OPLINE
 315 #undef LOAD_OPLINE
 316 #undef SAVE_OPLINE
 317 #define OPLINE EX(opline)
 318 #define DCL_OPLINE
 319 #define USE_OPLINE zend_op *opline = EX(opline);
 320 #define LOAD_OPLINE()
 321 #define SAVE_OPLINE()
 322 #undef CHECK_EXCEPTION
 323 #undef HANDLE_EXCEPTION
 324 #undef HANDLE_EXCEPTION_LEAVE
 325 #define CHECK_EXCEPTION() LOAD_OPLINE()
 326 #define HANDLE_EXCEPTION() LOAD_OPLINE(); ZEND_VM_CONTINUE()
 327 #define HANDLE_EXCEPTION_LEAVE() LOAD_OPLINE(); ZEND_VM_LEAVE()
 328 #define LOAD_REGS()
 329 #define ZEND_VM_CONTINUE()         return 0
 330 #define ZEND_VM_RETURN()           return 1
 331 #define ZEND_VM_ENTER()            return 2
 332 #define ZEND_VM_LEAVE()            return 3
 333 #define ZEND_VM_DISPATCH(opcode, opline) return zend_vm_get_opcode_handler(opcode, opline)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 334 
 335 #define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC
 336 
 337 ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC)
 338 {
 339         DCL_OPLINE
 340         zend_bool original_in_execution;
 341 
 342 
 343 
 344         original_in_execution = EG(in_execution);
 345         EG(in_execution) = 1;
 346 
 347         if (0) {
 348 zend_vm_enter:
 349                 execute_data = i_create_execute_data_from_op_array(EG(active_op_array), 1 TSRMLS_CC);
 350         }
 351 
 352         LOAD_REGS();
 353         LOAD_OPLINE();
 354 
 355         while (1) {
 356         int ret;
 357 #ifdef ZEND_WIN32
 358                 if (EG(timed_out)) {
 359                         zend_timeout(0);
 360                 }
 361 #endif
 362 
 363                 if ((ret = OPLINE->handler(execute_data TSRMLS_CC)) > 0) {
 364                         switch (ret) {
 365                                 case 1:
 366                                         EG(in_execution) = original_in_execution;
 367                                         return;
 368                                 case 2:
 369                                         goto zend_vm_enter;
 370                                         break;
 371                                 case 3:
 372                                         execute_data = EG(current_execute_data);
 373                                         break;
 374                                 default:
 375                                         break;
 376                         }
 377                 }
 378 
 379         }
 380         zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen");
 381 }
 382 
 383 ZEND_API void zend_execute(zend_op_array *op_array TSRMLS_DC)
 384 {
 385         if (EG(exception)) {
 386                 return;
 387         } 
 388         zend_execute_ex(i_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC) TSRMLS_CC);
 389 }
 390 
 391 static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
 392 {
 393         zend_bool nested = EX(nested);
 394         zend_op_array *op_array = EX(op_array);
 395 
 396         EG(current_execute_data) = EX(prev_execute_data);
 397         EG(opline_ptr) = NULL;
 398         if (!EG(active_symbol_table)) {
 399                 i_free_compiled_variables(execute_data TSRMLS_CC);
 400         }
 401 
 402         zend_vm_stack_free((char*)execute_data - (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T) TSRMLS_CC);
 403 
 404         if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) {
 405                 zval_ptr_dtor((zval**)&op_array->prototype);
 406         }
 407 
 408         if (nested) {
 409                 execute_data = EG(current_execute_data);
 410         }
 411         if (nested) {
 412                 USE_OPLINE
 413 
 414                 LOAD_REGS();
 415                 LOAD_OPLINE();
 416                 if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) {
 417 
 418                         EX(function_state).function = (zend_function *) EX(op_array);
 419                         EX(function_state).arguments = NULL;
 420 
 421                         EG(opline_ptr) = &EX(opline);
 422                         EG(active_op_array) = EX(op_array);
 423                         EG(return_value_ptr_ptr) = EX(original_return_value);
 424                         destroy_op_array(op_array TSRMLS_CC);
 425                         efree(op_array);
 426                         if (UNEXPECTED(EG(exception) != NULL)) {
 427                                 zend_throw_exception_internal(NULL TSRMLS_CC);
 428                                 HANDLE_EXCEPTION_LEAVE();
 429                         }
 430 
 431                         ZEND_VM_INC_OPCODE();
 432                         ZEND_VM_LEAVE();
 433                 } else {
 434                         EG(opline_ptr) = &EX(opline);
 435                         EG(active_op_array) = EX(op_array);
 436                         EG(return_value_ptr_ptr) = EX(original_return_value);
 437                         if (EG(active_symbol_table)) {
 438                                 zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
 439                         }
 440                         EG(active_symbol_table) = EX(symbol_table);
 441 
 442                         EX(function_state).function = (zend_function *) EX(op_array);
 443                         EX(function_state).arguments = NULL;
 444 
 445                         if (EG(This)) {
 446                                 if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
 447                                         if (EX(call)->is_ctor_result_used) {
 448                                                 Z_DELREF_P(EG(This));
 449                                         }
 450                                         if (Z_REFCOUNT_P(EG(This)) == 1) {
 451                                                 zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
 452                                         }
 453                                 }
 454                                 zval_ptr_dtor(&EG(This));
 455                         }
 456                         EG(This) = EX(current_this);
 457                         EG(scope) = EX(current_scope);
 458                         EG(called_scope) = EX(current_called_scope);
 459 
 460                         EX(call)--;
 461 
 462                         zend_vm_stack_clear_multiple(0 TSRMLS_CC);
 463 
 464                         if (UNEXPECTED(EG(exception) != NULL)) {
 465                                 zend_throw_exception_internal(NULL TSRMLS_CC);
 466                                 if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
 467                                         zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
 468                                 }
 469                                 HANDLE_EXCEPTION_LEAVE();
 470                         }
 471 
 472                         ZEND_VM_INC_OPCODE();
 473                         ZEND_VM_LEAVE();
 474                 }
 475         }
 476         ZEND_VM_RETURN();
 477 }
 478 
 479 static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
 480 {
 481         USE_OPLINE
 482         zend_bool should_change_scope = 0;
 483         zend_function *fbc = EX(function_state).function;
 484         zend_uint num_args;
 485 
 486         SAVE_OPLINE();
 487         EX(object) = EX(call)->object;
 488         if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
 489                 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) {
 490                         zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name, fbc->common.function_name);
 491                 }
 492                 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
 493                         zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
 494                                 fbc->common.scope ? fbc->common.scope->name : "",
 495                                 fbc->common.scope ? "::" : "",
 496                                 fbc->common.function_name);
 497                         if (UNEXPECTED(EG(exception) != NULL)) {
 498                                 HANDLE_EXCEPTION();
 499                         }
 500                 }
 501         }
 502         if (fbc->common.scope &&
 503                 !(fbc->common.fn_flags & ZEND_ACC_STATIC) &&
 504                 !EX(object)) {
 505 
 506                 if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
 507                         /* FIXME: output identifiers properly */
 508                         zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name, fbc->common.function_name);
 509                         if (UNEXPECTED(EG(exception) != NULL)) {
 510                                 HANDLE_EXCEPTION();
 511                         }
 512                 } else {
 513                         /* FIXME: output identifiers properly */
 514                         /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
 515                         zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name, fbc->common.function_name);
 516                 }
 517         }
 518 
 519         if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) {
 520                 should_change_scope = 1;
 521                 EX(current_this) = EG(This);
 522                 EX(current_scope) = EG(scope);
 523                 EX(current_called_scope) = EG(called_scope);
 524                 EG(This) = EX(object);
 525                 EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL;
 526                 EG(called_scope) = EX(call)->called_scope;
 527         }
 528 
 529         num_args = opline->extended_value + EX(call)->num_additional_args;
 530         if (EX(call)->num_additional_args) {
 531                 EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
 532         } else {
 533                 EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
 534                 zend_vm_stack_push((void*)(zend_uintptr_t) num_args TSRMLS_CC);
 535         }
 536         LOAD_OPLINE();
 537 
 538         if (fbc->type == ZEND_INTERNAL_FUNCTION) {
 539                 if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
 540                         zend_uint i;
 541                         void **p = EX(function_state).arguments - num_args;
 542 
 543                         for (i = 0; i < num_args; ++i, ++p) {
 544                                 zend_verify_arg_type(fbc, i + 1, (zval *) *p, 0, NULL TSRMLS_CC);
 545                         }
 546                 }
 547 
 548                 if (EXPECTED(EG(exception) == NULL)) {
 549                         temp_variable *ret = &EX_T(opline->result.var);
 550 
 551                         MAKE_STD_ZVAL(ret->var.ptr);
 552                         ZVAL_NULL(ret->var.ptr);
 553                         ret->var.ptr_ptr = &ret->var.ptr;
 554                         ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
 555 
 556                         if (!zend_execute_internal) {
 557                                 /* saves one function call if zend_execute_internal is not used */
 558                                 fbc->internal_function.handler(num_args, ret->var.ptr, &ret->var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
 559                         } else {
 560                                 zend_execute_internal(execute_data, NULL, RETURN_VALUE_USED(opline) TSRMLS_CC);
 561                         }
 562 
 563                         if (!RETURN_VALUE_USED(opline)) {
 564                                 zval_ptr_dtor(&ret->var.ptr);
 565                         }
 566                 } else if (RETURN_VALUE_USED(opline)) {
 567                         EX_T(opline->result.var).var.ptr = NULL;
 568                 }
 569         } else if (fbc->type == ZEND_USER_FUNCTION) {
 570                 temp_variable *ret = &EX_T(opline->result.var);
 571                 EX(original_return_value) = EG(return_value_ptr_ptr);
 572                 EG(active_symbol_table) = NULL;
 573                 EG(active_op_array) = &fbc->op_array;
 574                 EG(return_value_ptr_ptr) = NULL;
 575                 if (RETURN_VALUE_USED(opline)) {
 576                         ret->var.ptr = NULL;
 577                         EG(return_value_ptr_ptr) = &ret->var.ptr;
 578                         ret->var.ptr_ptr = &ret->var.ptr;
 579                         ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
 580                 }
 581 
 582                 if (UNEXPECTED((EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
 583                         if (RETURN_VALUE_USED(opline)) {
 584                                 ret->var.ptr = zend_generator_create_zval(EG(active_op_array) TSRMLS_CC);
 585                                 ret->var.fcall_returned_reference = 0;
 586                         }
 587                 } else if (EXPECTED(zend_execute_ex == execute_ex)) {
 588                         if (EXPECTED(EG(exception) == NULL)) {
 589                                 ZEND_VM_ENTER();
 590                         }
 591                 } else {
 592                         zend_execute(EG(active_op_array) TSRMLS_CC);
 593                 }
 594 
 595                 EG(opline_ptr) = &EX(opline);
 596                 EG(active_op_array) = EX(op_array);
 597                 EG(return_value_ptr_ptr) = EX(original_return_value);
 598                 if (EG(active_symbol_table)) {
 599                         zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
 600                 }
 601                 EG(active_symbol_table) = EX(symbol_table);
 602         } else { /* ZEND_OVERLOADED_FUNCTION */
 603                 MAKE_STD_ZVAL(EX_T(opline->result.var).var.ptr);
 604                 ZVAL_NULL(EX_T(opline->result.var).var.ptr);
 605 
 606                 /* Not sure what should be done here if it's a static method */
 607                 if (EXPECTED(EX(object) != NULL)) {
 608                         Z_OBJ_HT_P(EX(object))->call_method(fbc->common.function_name, num_args, EX_T(opline->result.var).var.ptr, &EX_T(opline->result.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
 609                 } else {
 610                         zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
 611                 }
 612 
 613                 if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
 614                         efree((char*)fbc->common.function_name);
 615                 }
 616                 efree(fbc);
 617 
 618                 if (!RETURN_VALUE_USED(opline)) {
 619                         zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
 620                 } else {
 621                         Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
 622                         Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
 623                         EX_T(opline->result.var).var.fcall_returned_reference = 0;
 624                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
 625                 }
 626         }
 627 
 628         EX(function_state).function = (zend_function *) EX(op_array);
 629         EX(function_state).arguments = NULL;
 630 
 631         if (should_change_scope) {
 632                 if (EG(This)) {
 633                         if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
 634                                 if (EX(call)->is_ctor_result_used) {
 635                                         Z_DELREF_P(EG(This));
 636                                 }
 637                                 if (Z_REFCOUNT_P(EG(This)) == 1) {
 638                                         zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
 639                                 }
 640                         }
 641                         zval_ptr_dtor(&EG(This));
 642                 }
 643                 EG(This) = EX(current_this);
 644                 EG(scope) = EX(current_scope);
 645                 EG(called_scope) = EX(current_called_scope);
 646         }
 647 
 648         EX(call)--;
 649 
 650         zend_vm_stack_clear_multiple(0 TSRMLS_CC);
 651 
 652         if (UNEXPECTED(EG(exception) != NULL)) {
 653                 zend_throw_exception_internal(NULL TSRMLS_CC);
 654                 if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
 655                         zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
 656                 }
 657                 HANDLE_EXCEPTION();
 658         }
 659 
 660         ZEND_VM_NEXT_OPCODE();
 661 }
 662 
 663 static int ZEND_FASTCALL  ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 664 {
 665         USE_OPLINE
 666 
 667 #if DEBUG_ZEND>=2
 668         printf("Jumping to %d\n", opline->op1.opline_num);
 669 #endif
 670         ZEND_VM_SET_OPCODE(opline->op1.jmp_addr);
 671         ZEND_VM_CONTINUE();
 672 }
 673 
 674 static int ZEND_FASTCALL  ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 675 {
 676         USE_OPLINE
 677         zval *tmp = &EX_T(opline->result.var).tmp_var;
 678 
 679         SAVE_OPLINE();
 680         tmp->value.str.val = emalloc(1);
 681         tmp->value.str.val[0] = 0;
 682         tmp->value.str.len = 0;
 683         Z_SET_REFCOUNT_P(tmp, 1);
 684         tmp->type = IS_STRING;
 685         Z_UNSET_ISREF_P(tmp);
 686         /*CHECK_EXCEPTION();*/
 687         ZEND_VM_NEXT_OPCODE();
 688 }
 689 
 690 static int ZEND_FASTCALL  ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 691 {
 692         EX(function_state).function = EX(call)->fbc;
 693         return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 694 }
 695 
 696 static int ZEND_FASTCALL  ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 697 {
 698         /* The generator object is stored in return_value_ptr_ptr */
 699         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
 700 
 701         /* Close the generator to free up resources */
 702         zend_generator_close(generator, 1 TSRMLS_CC);
 703 
 704         /* Pass execution back to handling code */
 705         ZEND_VM_RETURN();
 706 }
 707 
 708 static int ZEND_FASTCALL  ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 709 {
 710         USE_OPLINE
 711         zend_free_op free_op1;
 712         zval *args;
 713         int arg_num;
 714         SAVE_OPLINE();
 715 
 716         args = get_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, BP_VAR_R);
 717         arg_num = opline->op2.num + EX(call)->num_additional_args + 1;
 718 
 719         switch (Z_TYPE_P(args)) {
 720                 case IS_ARRAY: {
 721                         HashTable *ht = Z_ARRVAL_P(args);
 722                         HashPosition pos;
 723                         zval **arg_ptr, *arg;
 724 
 725                         ZEND_VM_STACK_GROW_IF_NEEDED(zend_hash_num_elements(ht));
 726 
 727                         for (zend_hash_internal_pointer_reset_ex(ht, &pos);
 728                              zend_hash_get_current_data_ex(ht, (void **) &arg_ptr, &pos) == SUCCESS;
 729                              zend_hash_move_forward_ex(ht, &pos), ++arg_num
 730                         ) {
 731                                 char *name;
 732                                 zend_uint name_len;
 733                                 zend_ulong index;
 734 
 735                                 if (zend_hash_get_current_key_ex(ht, &name, &name_len, &index, 0, &pos) == HASH_KEY_IS_STRING) {
 736                                         zend_error(E_RECOVERABLE_ERROR, "Cannot unpack array with string keys");
 737                                         FREE_OP(free_op1);
 738                                         CHECK_EXCEPTION();
 739                                         ZEND_VM_NEXT_OPCODE();
 740                                 }
 741 
 742                                 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
 743                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(arg_ptr);
 744                                         arg = *arg_ptr;
 745                                         Z_ADDREF_P(arg);
 746                                 } else if (Z_ISREF_PP(arg_ptr)) {
 747                                         ALLOC_ZVAL(arg);
 748                                         MAKE_COPY_ZVAL(arg_ptr, arg);
 749                                 } else {
 750                                         arg = *arg_ptr;
 751                                         Z_ADDREF_P(arg);
 752                                 }
 753 
 754                                 zend_vm_stack_push(arg TSRMLS_CC);
 755                                 EX(call)->num_additional_args++;
 756                         }
 757                         break;
 758                 }
 759                 case IS_OBJECT: {
 760                         zend_class_entry *ce = Z_OBJCE_P(args);
 761                         zend_object_iterator *iter;
 762 
 763                         if (!ce || !ce->get_iterator) {
 764                                 zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
 765                                 break;
 766                         }
 767 
 768                         iter = ce->get_iterator(ce, args, 0 TSRMLS_CC);
 769                         if (UNEXPECTED(!iter)) {
 770                                 FREE_OP(free_op1);
 771                                 if (!EG(exception)) {
 772                                         zend_throw_exception_ex(
 773                                                 NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name
 774                                         );
 775                                 }
 776                                 HANDLE_EXCEPTION();
 777                         }
 778 
 779                         if (iter->funcs->rewind) {
 780                                 iter->funcs->rewind(iter TSRMLS_CC);
 781                                 if (UNEXPECTED(EG(exception) != NULL)) {
 782                                         goto unpack_iter_dtor;
 783                                 }
 784                         }
 785 
 786                         for (; iter->funcs->valid(iter TSRMLS_CC) == SUCCESS; ++arg_num) {
 787                                 zval **arg_ptr, *arg;
 788 
 789                                 if (UNEXPECTED(EG(exception) != NULL)) {
 790                                         goto unpack_iter_dtor;
 791                                 }
 792 
 793                                 iter->funcs->get_current_data(iter, &arg_ptr TSRMLS_CC);
 794                                 if (UNEXPECTED(EG(exception) != NULL)) {
 795                                         goto unpack_iter_dtor;
 796                                 }
 797 
 798                                 if (iter->funcs->get_current_key) {
 799                                         zval key;
 800                                         iter->funcs->get_current_key(iter, &key TSRMLS_CC);
 801                                         if (UNEXPECTED(EG(exception) != NULL)) {
 802                                                 goto unpack_iter_dtor;
 803                                         }
 804 
 805                                         if (Z_TYPE(key) == IS_STRING) {
 806                                                 zend_error(E_RECOVERABLE_ERROR,
 807                                                         "Cannot unpack Traversable with string keys");
 808                                                 zval_dtor(&key);
 809                                                 goto unpack_iter_dtor;
 810                                         }
 811 
 812                                         zval_dtor(&key);
 813                                 }
 814 
 815                                 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
 816                                         zend_error(
 817                                                 E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
 818                                                 " by unpacking a Traversable, passing by-value instead", arg_num,
 819                                                 EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name : "",
 820                                                 EX(call)->fbc->common.scope ? "::" : "",
 821                                                 EX(call)->fbc->common.function_name
 822                                         );
 823                                 }
 824 
 825                                 if (Z_ISREF_PP(arg_ptr)) {
 826                                         ALLOC_ZVAL(arg);
 827                                         MAKE_COPY_ZVAL(arg_ptr, arg);
 828                                 } else {
 829                                         arg = *arg_ptr;
 830                                         Z_ADDREF_P(arg);
 831                                 }
 832 
 833                                 ZEND_VM_STACK_GROW_IF_NEEDED(1);
 834                                 zend_vm_stack_push(arg TSRMLS_CC);
 835                                 EX(call)->num_additional_args++;
 836 
 837                                 iter->funcs->move_forward(iter TSRMLS_CC);
 838                                 if (UNEXPECTED(EG(exception) != NULL)) {
 839                                         goto unpack_iter_dtor;
 840                                 }
 841                         }
 842 
 843 unpack_iter_dtor:
 844                         iter->funcs->dtor(iter TSRMLS_CC);
 845                         break;
 846                 }
 847                 default:
 848                         zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
 849         }
 850 
 851         FREE_OP(free_op1);
 852         CHECK_EXCEPTION();
 853         ZEND_VM_NEXT_OPCODE();
 854 }
 855 
 856 static int ZEND_FASTCALL  ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 857 {
 858         USE_OPLINE
 859         zend_uint arg_num = opline->op1.num;
 860         zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
 861 
 862         SAVE_OPLINE();
 863         if (UNEXPECTED(param == NULL)) {
 864                 if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value, NULL TSRMLS_CC)) {
 865                         const char *space;
 866                         const char *class_name;
 867                         zend_execute_data *ptr;
 868 
 869                         if (EG(active_op_array)->scope) {
 870                                 class_name = EG(active_op_array)->scope->name;
 871                                 space = "::";
 872                         } else {
 873                                 class_name = space = "";
 874                         }
 875                         ptr = EX(prev_execute_data);
 876 
 877                         if(ptr && ptr->op_array) {
 878                                 zend_error(E_WARNING, "Missing argument %u for %s%s%s(), called in %s on line %d and defined", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
 879                         } else {
 880                                 zend_error(E_WARNING, "Missing argument %u for %s%s%s()", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C));
 881                         }
 882                 }
 883         } else {
 884                 zval **var_ptr;
 885 
 886                 zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value, NULL TSRMLS_CC);
 887                 var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
 888                 Z_DELREF_PP(var_ptr);
 889                 *var_ptr = *param;
 890                 Z_ADDREF_PP(var_ptr);
 891         }
 892 
 893         CHECK_EXCEPTION();
 894         ZEND_VM_NEXT_OPCODE();
 895 }
 896 
 897 static int ZEND_FASTCALL  ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 898 {
 899         USE_OPLINE
 900         zend_uint arg_num = opline->op1.num;
 901         zend_uint arg_count = zend_vm_stack_get_args_count(TSRMLS_C);
 902         zval **var_ptr, *params;
 903 
 904         SAVE_OPLINE();
 905 
 906         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
 907         Z_DELREF_PP(var_ptr);
 908         MAKE_STD_ZVAL(params);
 909         *var_ptr = params;
 910 
 911         if (arg_num <= arg_count) {
 912                 array_init_size(params, arg_count - arg_num + 1);
 913         } else {
 914                 array_init(params);
 915         }
 916 
 917         for (; arg_num <= arg_count; ++arg_num) {
 918                 zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
 919                 zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value, NULL TSRMLS_CC);
 920                 zend_hash_next_index_insert(Z_ARRVAL_P(params), param, sizeof(zval *), NULL);
 921                 Z_ADDREF_PP(param);
 922         }
 923 
 924         CHECK_EXCEPTION();
 925         ZEND_VM_NEXT_OPCODE();
 926 }
 927 
 928 static int ZEND_FASTCALL  ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 929 {
 930         USE_OPLINE
 931         zval *object_zval;
 932         zend_function *constructor;
 933 
 934         SAVE_OPLINE();
 935         if (UNEXPECTED((EX_T(opline->op1.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) {
 936                 if (EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
 937                         zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", EX_T(opline->op1.var).class_entry->name);
 938                 } else if ((EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 939                         zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", EX_T(opline->op1.var).class_entry->name);
 940                 } else {
 941                         zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", EX_T(opline->op1.var).class_entry->name);
 942                 }
 943         }
 944         ALLOC_ZVAL(object_zval);
 945         object_init_ex(object_zval, EX_T(opline->op1.var).class_entry);
 946         INIT_PZVAL(object_zval);
 947 
 948         constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
 949 
 950         if (constructor == NULL) {
 951                 if (RETURN_VALUE_USED(opline)) {
 952                         AI_SET_PTR(&EX_T(opline->result.var), object_zval);
 953                 } else {
 954                         zval_ptr_dtor(&object_zval);
 955                 }
 956                 ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.opline_num);
 957         } else {
 958                 call_slot *call = EX(call_slots) + opline->extended_value;
 959 
 960                 if (RETURN_VALUE_USED(opline)) {
 961                         PZVAL_LOCK(object_zval);
 962                         AI_SET_PTR(&EX_T(opline->result.var), object_zval);
 963                 }
 964 
 965                 /* We are not handling overloaded classes right now */
 966                 call->fbc = constructor;
 967                 call->object = object_zval;
 968                 call->called_scope = EX_T(opline->op1.var).class_entry;
 969                 call->num_additional_args = 0;
 970                 call->is_ctor_call = 1;
 971                 call->is_ctor_result_used = RETURN_VALUE_USED(opline);
 972                 EX(call) = call;
 973 
 974                 CHECK_EXCEPTION();
 975                 ZEND_VM_NEXT_OPCODE();
 976         }
 977 }
 978 
 979 static int ZEND_FASTCALL  ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 980 {
 981         USE_OPLINE
 982 
 983         SAVE_OPLINE();
 984         Z_LVAL(EX_T(opline->result.var).tmp_var) = EG(error_reporting);
 985         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_LONG;  /* shouldn't be necessary */
 986         if (EX(old_error_reporting) == NULL) {
 987                 EX(old_error_reporting) = &EX_T(opline->result.var).tmp_var;
 988         }
 989 
 990         if (EG(error_reporting)) {
 991                 do {
 992                         EG(error_reporting) = 0;
 993                         if (!EG(error_reporting_ini_entry)) {
 994                                 if (UNEXPECTED(zend_hash_find(EG(ini_directives), "error_reporting", sizeof("error_reporting"), (void **) &EG(error_reporting_ini_entry)) == FAILURE)) {
 995                                         break;
 996                                 }
 997                         }
 998                         if (!EG(error_reporting_ini_entry)->modified) {
 999                                 if (!EG(modified_ini_directives)) {
1000                                         ALLOC_HASHTABLE(EG(modified_ini_directives));
1001                                         zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
1002                                 }
1003                                 if (EXPECTED(zend_hash_add(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting"), &EG(error_reporting_ini_entry), sizeof(zend_ini_entry*), NULL) == SUCCESS)) {
1004                                         EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
1005                                         EG(error_reporting_ini_entry)->orig_value_length = EG(error_reporting_ini_entry)->value_length;
1006                                         EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
1007                                         EG(error_reporting_ini_entry)->modified = 1;
1008                                 }
1009                         } else if (EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value) {
1010                                 efree(EG(error_reporting_ini_entry)->value);
1011                         }
1012                         EG(error_reporting_ini_entry)->value = estrndup("0", sizeof("0")-1);
1013                         EG(error_reporting_ini_entry)->value_length = sizeof("0")-1;
1014                 } while (0);
1015         }
1016         CHECK_EXCEPTION();
1017         ZEND_VM_NEXT_OPCODE();
1018 }
1019 
1020 static int ZEND_FASTCALL  ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1021 {
1022         SAVE_OPLINE();
1023         zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
1024         ZEND_VM_NEXT_OPCODE(); /* Never reached */
1025 }
1026 
1027 static int ZEND_FASTCALL  ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1028 {
1029         SAVE_OPLINE();
1030         if (!EG(no_extensions)) {
1031                 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, EX(op_array) TSRMLS_CC);
1032         }
1033         CHECK_EXCEPTION();
1034         ZEND_VM_NEXT_OPCODE();
1035 }
1036 
1037 static int ZEND_FASTCALL  ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1038 {
1039         SAVE_OPLINE();
1040         if (!EG(no_extensions)) {
1041                 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, EX(op_array) TSRMLS_CC);
1042         }
1043         CHECK_EXCEPTION();
1044         ZEND_VM_NEXT_OPCODE();
1045 }
1046 
1047 static int ZEND_FASTCALL  ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1048 {
1049         SAVE_OPLINE();
1050         if (!EG(no_extensions)) {
1051                 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, EX(op_array) TSRMLS_CC);
1052         }
1053         CHECK_EXCEPTION();
1054         ZEND_VM_NEXT_OPCODE();
1055 }
1056 
1057 static int ZEND_FASTCALL  ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1058 {
1059         USE_OPLINE
1060 
1061         SAVE_OPLINE();
1062         EX_T(opline->result.var).class_entry = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC);
1063         CHECK_EXCEPTION();
1064         ZEND_VM_NEXT_OPCODE();
1065 }
1066 
1067 static int ZEND_FASTCALL  ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1068 {
1069         USE_OPLINE
1070 
1071         SAVE_OPLINE();
1072         EX_T(opline->result.var).class_entry = do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
1073         CHECK_EXCEPTION();
1074         ZEND_VM_NEXT_OPCODE();
1075 }
1076 
1077 static int ZEND_FASTCALL  ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1078 {
1079         USE_OPLINE
1080         zend_class_entry **pce, **pce_orig;
1081 
1082         SAVE_OPLINE();
1083         if (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void**)&pce) == FAILURE ||
1084             (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void**)&pce_orig) == SUCCESS &&
1085              *pce != *pce_orig)) {
1086                 do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
1087         }
1088         CHECK_EXCEPTION();
1089         ZEND_VM_NEXT_OPCODE();
1090 }
1091 
1092 static int ZEND_FASTCALL  ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1093 {
1094         USE_OPLINE
1095 
1096         SAVE_OPLINE();
1097         do_bind_function(EX(op_array), opline, EG(function_table), 0);
1098         CHECK_EXCEPTION();
1099         ZEND_VM_NEXT_OPCODE();
1100 }
1101 
1102 static int ZEND_FASTCALL  ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1103 {
1104         USE_OPLINE
1105 
1106         SAVE_OPLINE();
1107         if (++EG(ticks_count)>=opline->extended_value) {
1108                 EG(ticks_count)=0;
1109                 if (zend_ticks_function) {
1110                         zend_ticks_function(opline->extended_value);
1111                 }
1112         }
1113         CHECK_EXCEPTION();
1114         ZEND_VM_NEXT_OPCODE();
1115 }
1116 
1117 static int ZEND_FASTCALL  ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1118 {
1119         ZEND_VM_NEXT_OPCODE();
1120 }
1121 
1122 static int ZEND_FASTCALL  ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1123 {
1124         ZEND_VM_NEXT_OPCODE();
1125 }
1126 
1127 static int ZEND_FASTCALL  ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1128 {
1129         USE_OPLINE
1130         zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
1131         zend_class_entry *trait;
1132 
1133         SAVE_OPLINE();
1134         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1135                 trait = CACHED_PTR(opline->op2.literal->cache_slot);
1136         } else {
1137                 trait = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv),
1138                                                  Z_STRLEN_P(opline->op2.zv),
1139                                                  opline->op2.literal + 1,
1140                                                  opline->extended_value TSRMLS_CC);
1141                 if (UNEXPECTED(trait == NULL)) {
1142                         CHECK_EXCEPTION();
1143                         ZEND_VM_NEXT_OPCODE();
1144                 }
1145                 if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) {
1146                         zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name, trait->name);
1147                 }
1148                 CACHE_PTR(opline->op2.literal->cache_slot, trait);
1149         }
1150 
1151         zend_do_implement_trait(ce, trait TSRMLS_CC);
1152 
1153         CHECK_EXCEPTION();
1154         ZEND_VM_NEXT_OPCODE();
1155 }
1156 
1157 static int ZEND_FASTCALL  ZEND_BIND_TRAITS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1158 {
1159         USE_OPLINE
1160         zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
1161 
1162         SAVE_OPLINE();
1163         zend_do_bind_traits(ce TSRMLS_CC);
1164         CHECK_EXCEPTION();
1165         ZEND_VM_NEXT_OPCODE();
1166 }
1167 
1168 static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1169 {
1170         zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
1171         int i;
1172         zend_uint catch_op_num = 0, finally_op_num = 0, finally_op_end = 0;
1173         void **stack_frame;
1174 
1175         /* Figure out where the next stack frame (which maybe contains pushed
1176          * arguments that have to be dtor'ed) starts */
1177         stack_frame = zend_vm_stack_frame_base(execute_data);
1178 
1179         /* If the exception was thrown during a function call there might be
1180          * arguments pushed to the stack that have to be dtor'ed. */
1181         while (zend_vm_stack_top(TSRMLS_C) != stack_frame) {
1182                 zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C);
1183                 zval_ptr_dtor(&stack_zval_p);
1184         }
1185 
1186         for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
1187                 if (EG(active_op_array)->try_catch_array[i].try_op > op_num) {
1188                         /* further blocks will not be relevant... */
1189                         break;
1190                 }
1191                 if (op_num < EG(active_op_array)->try_catch_array[i].catch_op) {
1192                         catch_op_num = EX(op_array)->try_catch_array[i].catch_op;
1193                 }
1194                 if (op_num < EG(active_op_array)->try_catch_array[i].finally_op) {
1195                         finally_op_num = EX(op_array)->try_catch_array[i].finally_op;
1196                 }
1197                 if (op_num >= EG(active_op_array)->try_catch_array[i].finally_op &&
1198                                 op_num < EG(active_op_array)->try_catch_array[i].finally_end) {
1199                         finally_op_end = EG(active_op_array)->try_catch_array[i].finally_end;
1200                 }
1201         }
1202 
1203         if (EX(call) >= EX(call_slots)) {
1204                 call_slot *call = EX(call);
1205                 do {
1206                         if (call->object) {
1207                                 if (call->is_ctor_call) {
1208                                         if (call->is_ctor_result_used) {
1209                                                 Z_DELREF_P(call->object);
1210                                         }
1211                                         if (Z_REFCOUNT_P(call->object) == 1) {
1212                                                 zend_object_store_ctor_failed(call->object TSRMLS_CC);
1213                                         }
1214                                 }
1215                                 zval_ptr_dtor(&call->object);
1216                         }
1217                         if (call->fbc->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) {
1218                                 efree((char *) call->fbc->common.function_name);
1219                                 efree(call->fbc);
1220                         }
1221                         call--;
1222                 } while (call >= EX(call_slots));
1223                 EX(call) = NULL;
1224         }
1225 
1226         for (i=0; i<EX(op_array)->last_brk_cont; i++) {
1227                 if (EX(op_array)->brk_cont_array[i].start < 0) {
1228                         continue;
1229                 } else if (EX(op_array)->brk_cont_array[i].start > op_num) {
1230                         /* further blocks will not be relevant... */
1231                         break;
1232                 } else if (op_num < EX(op_array)->brk_cont_array[i].brk) {
1233                         if (!catch_op_num ||
1234                             catch_op_num >= EX(op_array)->brk_cont_array[i].brk) {
1235                                 zend_op *brk_opline = &EX(op_array)->opcodes[EX(op_array)->brk_cont_array[i].brk];
1236 
1237                                 switch (brk_opline->opcode) {
1238                                         case ZEND_SWITCH_FREE:
1239                                                 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
1240                                                         zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
1241                                                 }
1242                                                 break;
1243                                         case ZEND_FREE:
1244                                                 if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
1245                                                         zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
1246                                                 }
1247                                                 break;
1248                                 }
1249                         }
1250                 }
1251         }
1252 
1253         /* restore previous error_reporting value */
1254         if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
1255                 zval restored_error_reporting;
1256 
1257                 Z_TYPE(restored_error_reporting) = IS_LONG;
1258                 Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
1259                 convert_to_string(&restored_error_reporting);
1260                 zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
1261                 zendi_zval_dtor(restored_error_reporting);
1262         }
1263         EX(old_error_reporting) = NULL;
1264 
1265         if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
1266                 if (EX(delayed_exception)) {
1267                         zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
1268                 }
1269                 EX(delayed_exception) = EG(exception);
1270                 EG(exception) = NULL;
1271                 EX(fast_ret) = NULL;
1272                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[finally_op_num]);
1273                 ZEND_VM_CONTINUE();
1274         } else if (catch_op_num) {
1275                 if (finally_op_end && catch_op_num > finally_op_end) {
1276                         /* we are going out of current finally scope */
1277                         if (EX(delayed_exception)) {
1278                                 zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
1279                                 EX(delayed_exception) = NULL;
1280                         }
1281                 }
1282                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[catch_op_num]);
1283                 ZEND_VM_CONTINUE();
1284         } else {
1285                 if (EX(delayed_exception)) {
1286                         zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
1287                         EX(delayed_exception) = NULL;
1288                 }
1289                 if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
1290                         return ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1291                 } else {
1292                         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1293                 }
1294         }
1295 }
1296 
1297 static int ZEND_FASTCALL  ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1298 {
1299         USE_OPLINE
1300 
1301         SAVE_OPLINE();
1302         zend_verify_abstract_class(EX_T(opline->op1.var).class_entry TSRMLS_CC);
1303         CHECK_EXCEPTION();
1304         ZEND_VM_NEXT_OPCODE();
1305 }
1306 
1307 static int ZEND_FASTCALL  ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1308 {
1309         USE_OPLINE
1310         int ret;
1311 
1312         SAVE_OPLINE();
1313         ret = zend_user_opcode_handlers[opline->opcode](ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL);
1314         LOAD_OPLINE();
1315 
1316         switch (ret) {
1317                 case ZEND_USER_OPCODE_CONTINUE:
1318                         ZEND_VM_CONTINUE();
1319                 case ZEND_USER_OPCODE_RETURN:
1320                         if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
1321                                 return ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1322                         } else {
1323                                 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1324                         }
1325                 case ZEND_USER_OPCODE_ENTER:
1326                         ZEND_VM_ENTER();
1327                 case ZEND_USER_OPCODE_LEAVE:
1328                         ZEND_VM_LEAVE();
1329                 case ZEND_USER_OPCODE_DISPATCH:
1330                         ZEND_VM_DISPATCH(opline->opcode, opline);
1331                 default:
1332                         ZEND_VM_DISPATCH((zend_uchar)(ret & 0xff), opline);
1333         }
1334 }
1335 
1336 static int ZEND_FASTCALL  ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1337 {
1338         if (EX(delayed_exception) != NULL) {
1339                 /* discard the previously thrown exception */
1340                 zval_ptr_dtor(&EX(delayed_exception));
1341                 EX(delayed_exception) = NULL;
1342         }
1343 
1344         ZEND_VM_NEXT_OPCODE();
1345 }
1346 
1347 static int ZEND_FASTCALL  ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1348 {
1349         USE_OPLINE
1350 
1351         if ((opline->extended_value & ZEND_FAST_CALL_FROM_CATCH) &&
1352             UNEXPECTED(EG(prev_exception) != NULL)) {
1353             /* in case of unhandled exception jump to catch block instead of finally */
1354                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
1355                 ZEND_VM_CONTINUE();
1356         }
1357         if (UNEXPECTED(EX(delayed_exception) != NULL)) {
1358                 EX(fast_ret) = NULL;
1359         } else {
1360                 EX(fast_ret) = opline;
1361         }
1362         ZEND_VM_SET_OPCODE(opline->op1.jmp_addr);
1363         ZEND_VM_CONTINUE();
1364 }
1365 
1366 static int ZEND_FASTCALL  ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1367 {
1368         if (EX(fast_ret)) {
1369                 ZEND_VM_SET_OPCODE(EX(fast_ret) + 1);
1370                 if ((EX(fast_ret)->extended_value & ZEND_FAST_CALL_FROM_FINALLY)) {
1371                         EX(fast_ret) = &EX(op_array)->opcodes[EX(fast_ret)->op2.opline_num];
1372                 }
1373                 ZEND_VM_CONTINUE();
1374         } else {
1375                 /* special case for unhandled exceptions */
1376                 USE_OPLINE
1377 
1378                 if (opline->extended_value == ZEND_FAST_RET_TO_FINALLY) {
1379                         ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
1380                         ZEND_VM_CONTINUE();
1381                 } else {
1382                         EG(exception) = EX(delayed_exception);
1383                         EX(delayed_exception) = NULL;
1384                         if (opline->extended_value == ZEND_FAST_RET_TO_CATCH) {
1385                                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
1386                                 ZEND_VM_CONTINUE();
1387                         } else if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
1388                                 return ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1389                         } else {
1390                                 return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
1391                         }
1392                 }
1393         }
1394 }
1395 
1396 static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1397 {
1398         USE_OPLINE
1399 
1400         SAVE_OPLINE();
1401         if (EG(exception)) {
1402                 zend_exception_save(TSRMLS_C);
1403         }
1404         if (IS_CONST == IS_UNUSED) {
1405                 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1406                 CHECK_EXCEPTION();
1407                 ZEND_VM_NEXT_OPCODE();
1408         } else {
1409 
1410                 zval *class_name = opline->op2.zv;
1411 
1412                 if (IS_CONST == IS_CONST) {
1413                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1414                                 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
1415                         } else {
1416                                 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
1417                                 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
1418                         }
1419                 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
1420                         EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
1421                 } else if (Z_TYPE_P(class_name) == IS_STRING) {
1422                         EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1423                 } else {
1424                         if (UNEXPECTED(EG(exception) != NULL)) {
1425                                 HANDLE_EXCEPTION();
1426                         }
1427                         zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1428                 }
1429 
1430                 CHECK_EXCEPTION();
1431                 ZEND_VM_NEXT_OPCODE();
1432         }
1433 }
1434 
1435 static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1436 {
1437         USE_OPLINE
1438         zval *function_name;
1439         call_slot *call = EX(call_slots) + opline->result.num;
1440 
1441         if (IS_CONST == IS_CONST) {
1442                 function_name = (zval*)(opline->op2.literal+1);
1443                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1444                         call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
1445                 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
1446                         SAVE_OPLINE();
1447                         zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
1448                 } else {
1449                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1450                 }
1451 
1452                 call->object = NULL;
1453                 call->called_scope = NULL;
1454                 call->num_additional_args = 0;
1455                 call->is_ctor_call = 0;
1456                 EX(call) = call;
1457 
1458                 /*CHECK_EXCEPTION();*/
1459                 ZEND_VM_NEXT_OPCODE();
1460         } else {
1461                 char *function_name_strval, *lcname;
1462                 int function_name_strlen;
1463 
1464 
1465                 SAVE_OPLINE();
1466                 function_name = opline->op2.zv;
1467 
1468                 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
1469                         function_name_strval = Z_STRVAL_P(function_name);
1470                         function_name_strlen = Z_STRLEN_P(function_name);
1471                         if (function_name_strval[0] == '\\') {
1472                             function_name_strlen -= 1;
1473                                 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
1474                         } else {
1475                                 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1476                         }
1477                         if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
1478                                 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1479                         }
1480                         efree(lcname);
1481 
1482                         call->object = NULL;
1483                         call->called_scope = NULL;
1484                         call->num_additional_args = 0;
1485                         call->is_ctor_call = 0;
1486                         EX(call) = call;
1487 
1488                         CHECK_EXCEPTION();
1489                         ZEND_VM_NEXT_OPCODE();
1490                 } else if (IS_CONST != IS_CONST && IS_CONST != IS_TMP_VAR &&
1491                     EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
1492                         Z_OBJ_HANDLER_P(function_name, get_closure) &&
1493                         Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
1494                         if (call->object) {
1495                                 Z_ADDREF_P(call->object);
1496                         }
1497                         if (IS_CONST == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 &&
1498                             call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
1499                                 /* Delay closure destruction until its invocation */
1500                                 call->fbc->common.prototype = (zend_function*)function_name;
1501                         } else {
1502 
1503                         }
1504 
1505                         call->num_additional_args = 0;
1506                         call->is_ctor_call = 0;
1507                         EX(call) = call;
1508 
1509                         CHECK_EXCEPTION();
1510                         ZEND_VM_NEXT_OPCODE();
1511                 } else if (IS_CONST != IS_CONST &&
1512                                 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
1513                                 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
1514                         zend_class_entry *ce;
1515                         zval **method = NULL;
1516                         zval **obj = NULL;
1517 
1518                         zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
1519                         zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
1520 
1521                         if (!obj || !method) {
1522                                 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
1523                         }
1524 
1525                         if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
1526                                 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
1527                         }
1528 
1529                         if (Z_TYPE_PP(method) != IS_STRING) {
1530                                 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
1531                         }
1532 
1533                         if (Z_TYPE_PP(obj) == IS_STRING) {
1534                                 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
1535                                 if (UNEXPECTED(ce == NULL)) {
1536                                         CHECK_EXCEPTION();
1537                                         ZEND_VM_NEXT_OPCODE();
1538                                 }
1539                                 call->called_scope = ce;
1540                                 call->object = NULL;
1541 
1542                                 if (ce->get_static_method) {
1543                                         call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
1544                                 } else {
1545                                         call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
1546                                 }
1547                         } else {
1548                                 call->object = *obj;
1549                                 ce = call->called_scope = Z_OBJCE_PP(obj);
1550 
1551                                 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
1552                                 if (UNEXPECTED(call->fbc == NULL)) {
1553                                         zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
1554                                 }
1555 
1556                                 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
1557                                         call->object = NULL;
1558                                 } else {
1559                                         if (!PZVAL_IS_REF(call->object)) {
1560                                                 Z_ADDREF_P(call->object); /* For $this pointer */
1561                                         } else {
1562                                                 zval *this_ptr;
1563                                                 ALLOC_ZVAL(this_ptr);
1564                                                 INIT_PZVAL_COPY(this_ptr, call->object);
1565                                                 zval_copy_ctor(this_ptr);
1566                                                 call->object = this_ptr;
1567                                         }
1568                                 }
1569                         }
1570 
1571                         if (UNEXPECTED(call->fbc == NULL)) {
1572                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
1573                         }
1574 
1575                         call->num_additional_args = 0;
1576                         call->is_ctor_call = 0;
1577                         EX(call) = call;
1578 
1579                         CHECK_EXCEPTION();
1580                         ZEND_VM_NEXT_OPCODE();
1581                 } else {
1582                         if (UNEXPECTED(EG(exception) != NULL)) {
1583                                 HANDLE_EXCEPTION();
1584                         }
1585                         zend_error_noreturn(E_ERROR, "Function name must be a string");
1586                         ZEND_VM_NEXT_OPCODE(); /* Never reached */
1587                 }
1588         }
1589 }
1590 
1591 
1592 static int ZEND_FASTCALL  ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1593 {
1594         USE_OPLINE
1595         zend_literal *func_name;
1596         call_slot *call = EX(call_slots) + opline->result.num;
1597 
1598         func_name = opline->op2.literal + 1;
1599         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1600                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
1601         } else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE) {
1602                 func_name++;
1603                 if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE)) {
1604                         SAVE_OPLINE();
1605                         zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
1606                 } else {
1607                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1608                 }
1609         } else {
1610                 CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1611         }
1612 
1613         call->object = NULL;
1614         call->called_scope = NULL;
1615         call->num_additional_args = 0;
1616         call->is_ctor_call = 0;
1617 
1618         EX(call) = call;
1619         ZEND_VM_NEXT_OPCODE();
1620 }
1621 
1622 static int ZEND_FASTCALL  ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1623 {
1624         USE_OPLINE
1625         zval *assignment_value;
1626         zend_uint arg_num = opline->op1.num;
1627         zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
1628         zval **var_ptr;
1629 
1630         SAVE_OPLINE();
1631         if (param == NULL) {
1632                 ALLOC_ZVAL(assignment_value);
1633                 *assignment_value = *opline->op2.zv;
1634                 if (IS_CONSTANT_TYPE(Z_TYPE_P(assignment_value))) {
1635                         Z_SET_REFCOUNT_P(assignment_value, 1);
1636                         zval_update_constant(&assignment_value, 0 TSRMLS_CC);
1637                 } else if (Z_TYPE_P(assignment_value) == IS_ARRAY) {
1638                         HashTable *ht;
1639 
1640                         ALLOC_HASHTABLE(ht);
1641                         zend_hash_init(ht, zend_hash_num_elements(Z_ARRVAL_P(assignment_value)), NULL, ZVAL_PTR_DTOR, 0);
1642                         zend_hash_copy(ht, Z_ARRVAL_P(assignment_value), (copy_ctor_func_t) zval_deep_copy, NULL, sizeof(zval *));
1643                         Z_ARRVAL_P(assignment_value) = ht;
1644                 } else {
1645                         zval_copy_ctor(assignment_value);
1646                 }
1647                 INIT_PZVAL(assignment_value);
1648         } else {
1649                 assignment_value = *param;
1650                 Z_ADDREF_P(assignment_value);
1651         }
1652 
1653         zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value, opline->op2.zv TSRMLS_CC);
1654         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
1655         zval_ptr_dtor(var_ptr);
1656         *var_ptr = assignment_value;
1657 
1658         CHECK_EXCEPTION();
1659         ZEND_VM_NEXT_OPCODE();
1660 }
1661 
1662 static int ZEND_FASTCALL  ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1663 {
1664         USE_OPLINE
1665         zend_brk_cont_element *el;
1666 
1667         SAVE_OPLINE();
1668         el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num,
1669                            EX(op_array), execute_data TSRMLS_CC);
1670         ZEND_VM_JMP(EX(op_array)->opcodes + el->brk);
1671 }
1672 
1673 static int ZEND_FASTCALL  ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1674 {
1675         USE_OPLINE
1676         zend_brk_cont_element *el;
1677 
1678         SAVE_OPLINE();
1679         el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num,
1680                            EX(op_array), execute_data TSRMLS_CC);
1681         ZEND_VM_JMP(EX(op_array)->opcodes + el->cont);
1682 }
1683 
1684 static int ZEND_FASTCALL  ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1685 {
1686         zend_op *brk_opline;
1687         USE_OPLINE
1688         zend_brk_cont_element *el;
1689 
1690         SAVE_OPLINE();
1691         el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->extended_value,
1692                            EX(op_array), execute_data TSRMLS_CC);
1693 
1694         brk_opline = EX(op_array)->opcodes + el->brk;
1695 
1696         switch (brk_opline->opcode) {
1697                 case ZEND_SWITCH_FREE:
1698                         if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
1699                                 zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
1700                         }
1701                         break;
1702                 case ZEND_FREE:
1703                         if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
1704                                 zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
1705                         }
1706                         break;
1707         }
1708         ZEND_VM_JMP(opline->op1.jmp_addr);
1709 }
1710 
1711 static int ZEND_FASTCALL  ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1712 {
1713         USE_OPLINE
1714         zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
1715         zend_class_entry *iface;
1716 
1717         SAVE_OPLINE();
1718         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1719                 iface = CACHED_PTR(opline->op2.literal->cache_slot);
1720         } else {
1721                 iface = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
1722                 if (UNEXPECTED(iface == NULL)) {
1723                         CHECK_EXCEPTION();
1724                         ZEND_VM_NEXT_OPCODE();
1725                 }
1726                 CACHE_PTR(opline->op2.literal->cache_slot, iface);
1727         }
1728 
1729         if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
1730                 zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
1731         }
1732         zend_do_implement_interface(ce, iface TSRMLS_CC);
1733 
1734         CHECK_EXCEPTION();
1735         ZEND_VM_NEXT_OPCODE();
1736 }
1737 
1738 static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1739 {
1740         USE_OPLINE
1741 
1742         SAVE_OPLINE();
1743         if (EG(exception)) {
1744                 zend_exception_save(TSRMLS_C);
1745         }
1746         if (IS_TMP_VAR == IS_UNUSED) {
1747                 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1748                 CHECK_EXCEPTION();
1749                 ZEND_VM_NEXT_OPCODE();
1750         } else {
1751                 zend_free_op free_op2;
1752                 zval *class_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
1753 
1754                 if (IS_TMP_VAR == IS_CONST) {
1755                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1756                                 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
1757                         } else {
1758                                 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
1759                                 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
1760                         }
1761                 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
1762                         EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
1763                 } else if (Z_TYPE_P(class_name) == IS_STRING) {
1764                         EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1765                 } else {
1766                         if (UNEXPECTED(EG(exception) != NULL)) {
1767                                 HANDLE_EXCEPTION();
1768                         }
1769                         zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1770                 }
1771 
1772                 zval_dtor(free_op2.var);
1773                 CHECK_EXCEPTION();
1774                 ZEND_VM_NEXT_OPCODE();
1775         }
1776 }
1777 
1778 static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1779 {
1780         USE_OPLINE
1781         zval *function_name;
1782         call_slot *call = EX(call_slots) + opline->result.num;
1783 
1784         if (IS_TMP_VAR == IS_CONST) {
1785                 function_name = (zval*)(opline->op2.literal+1);
1786                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1787                         call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
1788                 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
1789                         SAVE_OPLINE();
1790                         zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
1791                 } else {
1792                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1793                 }
1794 
1795                 call->object = NULL;
1796                 call->called_scope = NULL;
1797                 call->num_additional_args = 0;
1798                 call->is_ctor_call = 0;
1799                 EX(call) = call;
1800 
1801                 /*CHECK_EXCEPTION();*/
1802                 ZEND_VM_NEXT_OPCODE();
1803         } else {
1804                 char *function_name_strval, *lcname;
1805                 int function_name_strlen;
1806                 zend_free_op free_op2;
1807 
1808                 SAVE_OPLINE();
1809                 function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
1810 
1811                 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
1812                         function_name_strval = Z_STRVAL_P(function_name);
1813                         function_name_strlen = Z_STRLEN_P(function_name);
1814                         if (function_name_strval[0] == '\\') {
1815                             function_name_strlen -= 1;
1816                                 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
1817                         } else {
1818                                 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
1819                         }
1820                         if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
1821                                 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
1822                         }
1823                         efree(lcname);
1824                         zval_dtor(free_op2.var);
1825 
1826                         call->object = NULL;
1827                         call->called_scope = NULL;
1828                         call->num_additional_args = 0;
1829                         call->is_ctor_call = 0;
1830                         EX(call) = call;
1831 
1832                         CHECK_EXCEPTION();
1833                         ZEND_VM_NEXT_OPCODE();
1834                 } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_TMP_VAR &&
1835                     EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
1836                         Z_OBJ_HANDLER_P(function_name, get_closure) &&
1837                         Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
1838                         if (call->object) {
1839                                 Z_ADDREF_P(call->object);
1840                         }
1841                         if (IS_TMP_VAR == IS_VAR && 1 && Z_REFCOUNT_P(function_name) == 1 &&
1842                             call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
1843                                 /* Delay closure destruction until its invocation */
1844                                 call->fbc->common.prototype = (zend_function*)function_name;
1845                         } else {
1846                                 zval_dtor(free_op2.var);
1847                         }
1848 
1849                         call->num_additional_args = 0;
1850                         call->is_ctor_call = 0;
1851                         EX(call) = call;
1852 
1853                         CHECK_EXCEPTION();
1854                         ZEND_VM_NEXT_OPCODE();
1855                 } else if (IS_TMP_VAR != IS_CONST &&
1856                                 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
1857                                 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
1858                         zend_class_entry *ce;
1859                         zval **method = NULL;
1860                         zval **obj = NULL;
1861 
1862                         zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
1863                         zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
1864 
1865                         if (!obj || !method) {
1866                                 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
1867                         }
1868 
1869                         if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
1870                                 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
1871                         }
1872 
1873                         if (Z_TYPE_PP(method) != IS_STRING) {
1874                                 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
1875                         }
1876 
1877                         if (Z_TYPE_PP(obj) == IS_STRING) {
1878                                 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
1879                                 if (UNEXPECTED(ce == NULL)) {
1880                                         CHECK_EXCEPTION();
1881                                         ZEND_VM_NEXT_OPCODE();
1882                                 }
1883                                 call->called_scope = ce;
1884                                 call->object = NULL;
1885 
1886                                 if (ce->get_static_method) {
1887                                         call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
1888                                 } else {
1889                                         call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
1890                                 }
1891                         } else {
1892                                 call->object = *obj;
1893                                 ce = call->called_scope = Z_OBJCE_PP(obj);
1894 
1895                                 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
1896                                 if (UNEXPECTED(call->fbc == NULL)) {
1897                                         zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
1898                                 }
1899 
1900                                 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
1901                                         call->object = NULL;
1902                                 } else {
1903                                         if (!PZVAL_IS_REF(call->object)) {
1904                                                 Z_ADDREF_P(call->object); /* For $this pointer */
1905                                         } else {
1906                                                 zval *this_ptr;
1907                                                 ALLOC_ZVAL(this_ptr);
1908                                                 INIT_PZVAL_COPY(this_ptr, call->object);
1909                                                 zval_copy_ctor(this_ptr);
1910                                                 call->object = this_ptr;
1911                                         }
1912                                 }
1913                         }
1914 
1915                         if (UNEXPECTED(call->fbc == NULL)) {
1916                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
1917                         }
1918 
1919                         call->num_additional_args = 0;
1920                         call->is_ctor_call = 0;
1921                         EX(call) = call;
1922 
1923                         zval_dtor(free_op2.var);
1924                         CHECK_EXCEPTION();
1925                         ZEND_VM_NEXT_OPCODE();
1926                 } else {
1927                         if (UNEXPECTED(EG(exception) != NULL)) {
1928                                 HANDLE_EXCEPTION();
1929                         }
1930                         zend_error_noreturn(E_ERROR, "Function name must be a string");
1931                         ZEND_VM_NEXT_OPCODE(); /* Never reached */
1932                 }
1933         }
1934 }
1935 
1936 
1937 static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1938 {
1939         USE_OPLINE
1940 
1941         SAVE_OPLINE();
1942         if (EG(exception)) {
1943                 zend_exception_save(TSRMLS_C);
1944         }
1945         if (IS_VAR == IS_UNUSED) {
1946                 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
1947                 CHECK_EXCEPTION();
1948                 ZEND_VM_NEXT_OPCODE();
1949         } else {
1950                 zend_free_op free_op2;
1951                 zval *class_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
1952 
1953                 if (IS_VAR == IS_CONST) {
1954                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1955                                 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
1956                         } else {
1957                                 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
1958                                 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
1959                         }
1960                 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
1961                         EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
1962                 } else if (Z_TYPE_P(class_name) == IS_STRING) {
1963                         EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
1964                 } else {
1965                         if (UNEXPECTED(EG(exception) != NULL)) {
1966                                 HANDLE_EXCEPTION();
1967                         }
1968                         zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
1969                 }
1970 
1971                 zval_ptr_dtor_nogc(&free_op2.var);
1972                 CHECK_EXCEPTION();
1973                 ZEND_VM_NEXT_OPCODE();
1974         }
1975 }
1976 
1977 static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1978 {
1979         USE_OPLINE
1980         zval *function_name;
1981         call_slot *call = EX(call_slots) + opline->result.num;
1982 
1983         if (IS_VAR == IS_CONST) {
1984                 function_name = (zval*)(opline->op2.literal+1);
1985                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
1986                         call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
1987                 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
1988                         SAVE_OPLINE();
1989                         zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
1990                 } else {
1991                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
1992                 }
1993 
1994                 call->object = NULL;
1995                 call->called_scope = NULL;
1996                 call->num_additional_args = 0;
1997                 call->is_ctor_call = 0;
1998                 EX(call) = call;
1999 
2000                 /*CHECK_EXCEPTION();*/
2001                 ZEND_VM_NEXT_OPCODE();
2002         } else {
2003                 char *function_name_strval, *lcname;
2004                 int function_name_strlen;
2005                 zend_free_op free_op2;
2006 
2007                 SAVE_OPLINE();
2008                 function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
2009 
2010                 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
2011                         function_name_strval = Z_STRVAL_P(function_name);
2012                         function_name_strlen = Z_STRLEN_P(function_name);
2013                         if (function_name_strval[0] == '\\') {
2014                             function_name_strlen -= 1;
2015                                 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
2016                         } else {
2017                                 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
2018                         }
2019                         if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
2020                                 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
2021                         }
2022                         efree(lcname);
2023                         zval_ptr_dtor_nogc(&free_op2.var);
2024 
2025                         call->object = NULL;
2026                         call->called_scope = NULL;
2027                         call->num_additional_args = 0;
2028                         call->is_ctor_call = 0;
2029                         EX(call) = call;
2030 
2031                         CHECK_EXCEPTION();
2032                         ZEND_VM_NEXT_OPCODE();
2033                 } else if (IS_VAR != IS_CONST && IS_VAR != IS_TMP_VAR &&
2034                     EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
2035                         Z_OBJ_HANDLER_P(function_name, get_closure) &&
2036                         Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
2037                         if (call->object) {
2038                                 Z_ADDREF_P(call->object);
2039                         }
2040                         if (IS_VAR == IS_VAR && (free_op2.var != NULL) && Z_REFCOUNT_P(function_name) == 1 &&
2041                             call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
2042                                 /* Delay closure destruction until its invocation */
2043                                 call->fbc->common.prototype = (zend_function*)function_name;
2044                         } else {
2045                                 zval_ptr_dtor_nogc(&free_op2.var);
2046                         }
2047 
2048                         call->num_additional_args = 0;
2049                         call->is_ctor_call = 0;
2050                         EX(call) = call;
2051 
2052                         CHECK_EXCEPTION();
2053                         ZEND_VM_NEXT_OPCODE();
2054                 } else if (IS_VAR != IS_CONST &&
2055                                 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
2056                                 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
2057                         zend_class_entry *ce;
2058                         zval **method = NULL;
2059                         zval **obj = NULL;
2060 
2061                         zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
2062                         zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
2063 
2064                         if (!obj || !method) {
2065                                 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
2066                         }
2067 
2068                         if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
2069                                 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
2070                         }
2071 
2072                         if (Z_TYPE_PP(method) != IS_STRING) {
2073                                 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
2074                         }
2075 
2076                         if (Z_TYPE_PP(obj) == IS_STRING) {
2077                                 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
2078                                 if (UNEXPECTED(ce == NULL)) {
2079                                         CHECK_EXCEPTION();
2080                                         ZEND_VM_NEXT_OPCODE();
2081                                 }
2082                                 call->called_scope = ce;
2083                                 call->object = NULL;
2084 
2085                                 if (ce->get_static_method) {
2086                                         call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
2087                                 } else {
2088                                         call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2089                                 }
2090                         } else {
2091                                 call->object = *obj;
2092                                 ce = call->called_scope = Z_OBJCE_PP(obj);
2093 
2094                                 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2095                                 if (UNEXPECTED(call->fbc == NULL)) {
2096                                         zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
2097                                 }
2098 
2099                                 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
2100                                         call->object = NULL;
2101                                 } else {
2102                                         if (!PZVAL_IS_REF(call->object)) {
2103                                                 Z_ADDREF_P(call->object); /* For $this pointer */
2104                                         } else {
2105                                                 zval *this_ptr;
2106                                                 ALLOC_ZVAL(this_ptr);
2107                                                 INIT_PZVAL_COPY(this_ptr, call->object);
2108                                                 zval_copy_ctor(this_ptr);
2109                                                 call->object = this_ptr;
2110                                         }
2111                                 }
2112                         }
2113 
2114                         if (UNEXPECTED(call->fbc == NULL)) {
2115                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
2116                         }
2117 
2118                         call->num_additional_args = 0;
2119                         call->is_ctor_call = 0;
2120                         EX(call) = call;
2121 
2122                         zval_ptr_dtor_nogc(&free_op2.var);
2123                         CHECK_EXCEPTION();
2124                         ZEND_VM_NEXT_OPCODE();
2125                 } else {
2126                         if (UNEXPECTED(EG(exception) != NULL)) {
2127                                 HANDLE_EXCEPTION();
2128                         }
2129                         zend_error_noreturn(E_ERROR, "Function name must be a string");
2130                         ZEND_VM_NEXT_OPCODE(); /* Never reached */
2131                 }
2132         }
2133 }
2134 
2135 
2136 static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2137 {
2138         USE_OPLINE
2139 
2140         SAVE_OPLINE();
2141         if (EG(exception)) {
2142                 zend_exception_save(TSRMLS_C);
2143         }
2144         if (IS_UNUSED == IS_UNUSED) {
2145                 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
2146                 CHECK_EXCEPTION();
2147                 ZEND_VM_NEXT_OPCODE();
2148         } else {
2149 
2150                 zval *class_name = NULL;
2151 
2152                 if (IS_UNUSED == IS_CONST) {
2153                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2154                                 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
2155                         } else {
2156                                 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
2157                                 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
2158                         }
2159                 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
2160                         EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
2161                 } else if (Z_TYPE_P(class_name) == IS_STRING) {
2162                         EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
2163                 } else {
2164                         if (UNEXPECTED(EG(exception) != NULL)) {
2165                                 HANDLE_EXCEPTION();
2166                         }
2167                         zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
2168                 }
2169 
2170                 CHECK_EXCEPTION();
2171                 ZEND_VM_NEXT_OPCODE();
2172         }
2173 }
2174 
2175 static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2176 {
2177         USE_OPLINE
2178 
2179         SAVE_OPLINE();
2180         if (EG(exception)) {
2181                 zend_exception_save(TSRMLS_C);
2182         }
2183         if (IS_CV == IS_UNUSED) {
2184                 EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
2185                 CHECK_EXCEPTION();
2186                 ZEND_VM_NEXT_OPCODE();
2187         } else {
2188 
2189                 zval *class_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
2190 
2191                 if (IS_CV == IS_CONST) {
2192                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2193                                 EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
2194                         } else {
2195                                 EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
2196                                 CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
2197                         }
2198                 } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
2199                         EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
2200                 } else if (Z_TYPE_P(class_name) == IS_STRING) {
2201                         EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
2202                 } else {
2203                         if (UNEXPECTED(EG(exception) != NULL)) {
2204                                 HANDLE_EXCEPTION();
2205                         }
2206                         zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
2207                 }
2208 
2209                 CHECK_EXCEPTION();
2210                 ZEND_VM_NEXT_OPCODE();
2211         }
2212 }
2213 
2214 static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2215 {
2216         USE_OPLINE
2217         zval *function_name;
2218         call_slot *call = EX(call_slots) + opline->result.num;
2219 
2220         if (IS_CV == IS_CONST) {
2221                 function_name = (zval*)(opline->op2.literal+1);
2222                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
2223                         call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
2224                 } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
2225                         SAVE_OPLINE();
2226                         zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
2227                 } else {
2228                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
2229                 }
2230 
2231                 call->object = NULL;
2232                 call->called_scope = NULL;
2233                 call->num_additional_args = 0;
2234                 call->is_ctor_call = 0;
2235                 EX(call) = call;
2236 
2237                 /*CHECK_EXCEPTION();*/
2238                 ZEND_VM_NEXT_OPCODE();
2239         } else {
2240                 char *function_name_strval, *lcname;
2241                 int function_name_strlen;
2242 
2243 
2244                 SAVE_OPLINE();
2245                 function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
2246 
2247                 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
2248                         function_name_strval = Z_STRVAL_P(function_name);
2249                         function_name_strlen = Z_STRLEN_P(function_name);
2250                         if (function_name_strval[0] == '\\') {
2251                             function_name_strlen -= 1;
2252                                 lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
2253                         } else {
2254                                 lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
2255                         }
2256                         if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
2257                                 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
2258                         }
2259                         efree(lcname);
2260 
2261                         call->object = NULL;
2262                         call->called_scope = NULL;
2263                         call->num_additional_args = 0;
2264                         call->is_ctor_call = 0;
2265                         EX(call) = call;
2266 
2267                         CHECK_EXCEPTION();
2268                         ZEND_VM_NEXT_OPCODE();
2269                 } else if (IS_CV != IS_CONST && IS_CV != IS_TMP_VAR &&
2270                     EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) &&
2271                         Z_OBJ_HANDLER_P(function_name, get_closure) &&
2272                         Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
2273                         if (call->object) {
2274                                 Z_ADDREF_P(call->object);
2275                         }
2276                         if (IS_CV == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 &&
2277                             call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
2278                                 /* Delay closure destruction until its invocation */
2279                                 call->fbc->common.prototype = (zend_function*)function_name;
2280                         } else {
2281 
2282                         }
2283 
2284                         call->num_additional_args = 0;
2285                         call->is_ctor_call = 0;
2286                         EX(call) = call;
2287 
2288                         CHECK_EXCEPTION();
2289                         ZEND_VM_NEXT_OPCODE();
2290                 } else if (IS_CV != IS_CONST &&
2291                                 EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
2292                                 zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
2293                         zend_class_entry *ce;
2294                         zval **method = NULL;
2295                         zval **obj = NULL;
2296 
2297                         zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
2298                         zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
2299 
2300                         if (!obj || !method) {
2301                                 zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
2302                         }
2303 
2304                         if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
2305                                 zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
2306                         }
2307 
2308                         if (Z_TYPE_PP(method) != IS_STRING) {
2309                                 zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
2310                         }
2311 
2312                         if (Z_TYPE_PP(obj) == IS_STRING) {
2313                                 ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
2314                                 if (UNEXPECTED(ce == NULL)) {
2315                                         CHECK_EXCEPTION();
2316                                         ZEND_VM_NEXT_OPCODE();
2317                                 }
2318                                 call->called_scope = ce;
2319                                 call->object = NULL;
2320 
2321                                 if (ce->get_static_method) {
2322                                         call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
2323                                 } else {
2324                                         call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2325                                 }
2326                         } else {
2327                                 call->object = *obj;
2328                                 ce = call->called_scope = Z_OBJCE_PP(obj);
2329 
2330                                 call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
2331                                 if (UNEXPECTED(call->fbc == NULL)) {
2332                                         zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
2333                                 }
2334 
2335                                 if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
2336                                         call->object = NULL;
2337                                 } else {
2338                                         if (!PZVAL_IS_REF(call->object)) {
2339                                                 Z_ADDREF_P(call->object); /* For $this pointer */
2340                                         } else {
2341                                                 zval *this_ptr;
2342                                                 ALLOC_ZVAL(this_ptr);
2343                                                 INIT_PZVAL_COPY(this_ptr, call->object);
2344                                                 zval_copy_ctor(this_ptr);
2345                                                 call->object = this_ptr;
2346                                         }
2347                                 }
2348                         }
2349 
2350                         if (UNEXPECTED(call->fbc == NULL)) {
2351                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
2352                         }
2353 
2354                         call->num_additional_args = 0;
2355                         call->is_ctor_call = 0;
2356                         EX(call) = call;
2357 
2358                         CHECK_EXCEPTION();
2359                         ZEND_VM_NEXT_OPCODE();
2360                 } else {
2361                         if (UNEXPECTED(EG(exception) != NULL)) {
2362                                 HANDLE_EXCEPTION();
2363                         }
2364                         zend_error_noreturn(E_ERROR, "Function name must be a string");
2365                         ZEND_VM_NEXT_OPCODE(); /* Never reached */
2366                 }
2367         }
2368 }
2369 
2370 
2371 static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2372 {
2373         USE_OPLINE
2374 
2375 
2376         SAVE_OPLINE();
2377         bitwise_not_function(&EX_T(opline->result.var).tmp_var,
2378                 opline->op1.zv TSRMLS_CC);
2379 
2380         CHECK_EXCEPTION();
2381         ZEND_VM_NEXT_OPCODE();
2382 }
2383 
2384 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2385 {
2386         USE_OPLINE
2387 
2388 
2389         SAVE_OPLINE();
2390         boolean_not_function(&EX_T(opline->result.var).tmp_var,
2391                 opline->op1.zv TSRMLS_CC);
2392 
2393         CHECK_EXCEPTION();
2394         ZEND_VM_NEXT_OPCODE();
2395 }
2396 
2397 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2398 {
2399         USE_OPLINE
2400 
2401         zval *z;
2402 
2403         SAVE_OPLINE();
2404         z = opline->op1.zv;
2405 
2406         if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
2407                 INIT_PZVAL(z);
2408         }
2409         zend_print_variable(z);
2410 
2411         CHECK_EXCEPTION();
2412         ZEND_VM_NEXT_OPCODE();
2413 }
2414 
2415 static int ZEND_FASTCALL  ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2416 {
2417         USE_OPLINE
2418 
2419         ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
2420         return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2421 }
2422 
2423 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2424 {
2425         USE_OPLINE
2426 
2427         zval *val;
2428         int ret;
2429 
2430         SAVE_OPLINE();
2431         val = opline->op1.zv;
2432 
2433         if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2434                 ret = Z_LVAL_P(val);
2435         } else {
2436                 ret = i_zend_is_true(val);
2437 
2438                 if (UNEXPECTED(EG(exception) != NULL)) {
2439                         HANDLE_EXCEPTION();
2440                 }
2441         }
2442         if (!ret) {
2443 #if DEBUG_ZEND>=2
2444                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2445 #endif
2446                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2447                 ZEND_VM_CONTINUE();
2448         }
2449 
2450         ZEND_VM_NEXT_OPCODE();
2451 }
2452 
2453 static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2454 {
2455         USE_OPLINE
2456 
2457         zval *val;
2458         int ret;
2459 
2460         SAVE_OPLINE();
2461         val = opline->op1.zv;
2462 
2463         if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2464                 ret = Z_LVAL_P(val);
2465         } else {
2466                 ret = i_zend_is_true(val);
2467 
2468                 if (UNEXPECTED(EG(exception) != NULL)) {
2469                         HANDLE_EXCEPTION();
2470                 }
2471         }
2472         if (ret) {
2473 #if DEBUG_ZEND>=2
2474                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2475 #endif
2476                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2477                 ZEND_VM_CONTINUE();
2478         }
2479 
2480         ZEND_VM_NEXT_OPCODE();
2481 }
2482 
2483 static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2484 {
2485         USE_OPLINE
2486 
2487         zval *val;
2488         int retval;
2489 
2490         SAVE_OPLINE();
2491         val = opline->op1.zv;
2492 
2493         if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2494                 retval = Z_LVAL_P(val);
2495         } else {
2496                 retval = i_zend_is_true(val);
2497 
2498                 if (UNEXPECTED(EG(exception) != NULL)) {
2499                         HANDLE_EXCEPTION();
2500                 }
2501         }
2502         if (EXPECTED(retval != 0)) {
2503 #if DEBUG_ZEND>=2
2504                 printf("Conditional jmp on true to %d\n", opline->extended_value);
2505 #endif
2506                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
2507                 ZEND_VM_CONTINUE(); /* CHECK_ME */
2508         } else {
2509 #if DEBUG_ZEND>=2
2510                 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
2511 #endif
2512                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
2513                 ZEND_VM_CONTINUE(); /* CHECK_ME */
2514         }
2515 }
2516 
2517 static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2518 {
2519         USE_OPLINE
2520 
2521         zval *val;
2522         int retval;
2523 
2524         SAVE_OPLINE();
2525         val = opline->op1.zv;
2526 
2527         if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2528                 retval = Z_LVAL_P(val);
2529         } else {
2530                 retval = i_zend_is_true(val);
2531 
2532                 if (UNEXPECTED(EG(exception) != NULL)) {
2533                         HANDLE_EXCEPTION();
2534                 }
2535         }
2536         Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
2537         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
2538         if (!retval) {
2539 #if DEBUG_ZEND>=2
2540                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2541 #endif
2542                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2543                 ZEND_VM_CONTINUE();
2544         }
2545         ZEND_VM_NEXT_OPCODE();
2546 }
2547 
2548 static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2549 {
2550         USE_OPLINE
2551 
2552         zval *val;
2553         int retval;
2554 
2555         SAVE_OPLINE();
2556         val = opline->op1.zv;
2557 
2558         if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
2559                 retval = Z_LVAL_P(val);
2560         } else {
2561                 retval = i_zend_is_true(val);
2562 
2563                 if (UNEXPECTED(EG(exception) != NULL)) {
2564                         HANDLE_EXCEPTION();
2565                 }
2566         }
2567         Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
2568         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
2569         if (retval) {
2570 #if DEBUG_ZEND>=2
2571                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
2572 #endif
2573                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
2574                 ZEND_VM_CONTINUE();
2575         }
2576         ZEND_VM_NEXT_OPCODE();
2577 }
2578 
2579 static int ZEND_FASTCALL  ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2580 {
2581         USE_OPLINE
2582 
2583         zval *fname = opline->op1.zv;
2584         call_slot *call = EX(call_slots) + opline->op2.num;
2585 
2586         if (CACHED_PTR(opline->op1.literal->cache_slot)) {
2587                 EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot);
2588         } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(fname), Z_STRLEN_P(fname)+1, Z_HASH_P(fname), (void **) &EX(function_state).function)==FAILURE)) {
2589             SAVE_OPLINE();
2590                 zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
2591         } else {
2592                 CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function);
2593         }
2594 
2595         call->fbc = EX(function_state).function;
2596         call->object = NULL;
2597         call->called_scope = NULL;
2598         call->num_additional_args = 0;
2599         call->is_ctor_call = 0;
2600         EX(call) = call;
2601 
2602         return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2603 }
2604 
2605 static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2606 {
2607         USE_OPLINE
2608         zval *retval_ptr;
2609 
2610 
2611         SAVE_OPLINE();
2612         retval_ptr = opline->op1.zv;
2613 
2614         if (!EG(return_value_ptr_ptr)) {
2615 
2616         } else {
2617                 if (IS_CONST == IS_CONST ||
2618                     IS_CONST == IS_TMP_VAR ||
2619                     PZVAL_IS_REF(retval_ptr)) {
2620                         zval *ret;
2621 
2622                         ALLOC_ZVAL(ret);
2623                         INIT_PZVAL_COPY(ret, retval_ptr);
2624                         if (IS_CONST != IS_TMP_VAR) {
2625                                 zval_copy_ctor(ret);
2626                         }
2627                         *EG(return_value_ptr_ptr) = ret;
2628 
2629                 } else if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
2630                            retval_ptr == &EG(uninitialized_zval)) {
2631                         zval *ret;
2632 
2633                         if (IS_CONST == IS_VAR) {
2634                                 Z_DELREF_P(retval_ptr);
2635                         }
2636                         ALLOC_INIT_ZVAL(ret);
2637                         *EG(return_value_ptr_ptr) = ret;
2638                 } else {
2639                         *EG(return_value_ptr_ptr) = retval_ptr;
2640                         if (IS_CONST == IS_CV) {
2641                                 Z_ADDREF_P(retval_ptr);
2642                         }
2643                 }
2644         }
2645         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2646 }
2647 
2648 static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2649 {
2650         USE_OPLINE
2651         zval *retval_ptr;
2652         zval **retval_ptr_ptr;
2653 
2654 
2655         SAVE_OPLINE();
2656 
2657         do {
2658                 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR ||
2659                     (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
2660                         /* Not supposed to happen, but we'll allow it */
2661                         zend_error(E_NOTICE, "Only variable references should be returned by reference");
2662 
2663                         retval_ptr = opline->op1.zv;
2664                         if (!EG(return_value_ptr_ptr)) {
2665                                 if (IS_CONST == IS_TMP_VAR) {
2666 
2667                                 }
2668                         } else if (!0) { /* Not a temp var */
2669                                 zval *ret;
2670 
2671                                 ALLOC_ZVAL(ret);
2672                                 INIT_PZVAL_COPY(ret, retval_ptr);
2673                                 zval_copy_ctor(ret);
2674                                 *EG(return_value_ptr_ptr) = ret;
2675                         } else {
2676                                 zval *ret;
2677 
2678                                 ALLOC_ZVAL(ret);
2679                                 INIT_PZVAL_COPY(ret, retval_ptr);
2680                                 *EG(return_value_ptr_ptr) = ret;
2681                         }
2682                         break;
2683                 }
2684 
2685                 retval_ptr_ptr = NULL;
2686 
2687                 if (IS_CONST == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
2688                         zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
2689                 }
2690 
2691                 if (IS_CONST == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
2692                         if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
2693                             EX_T(opline->op1.var).var.fcall_returned_reference) {
2694                         } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
2695                                 zend_error(E_NOTICE, "Only variable references should be returned by reference");
2696                                 if (EG(return_value_ptr_ptr)) {
2697                                         zval *ret;
2698 
2699                                         ALLOC_ZVAL(ret);
2700                                         INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
2701                                         zval_copy_ctor(ret);
2702                                         *EG(return_value_ptr_ptr) = ret;
2703                                 }
2704                                 break;
2705                         }
2706                 }
2707 
2708                 if (EG(return_value_ptr_ptr)) {
2709                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
2710                         Z_ADDREF_PP(retval_ptr_ptr);
2711 
2712                         *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
2713                 }
2714         } while (0);
2715 
2716         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
2717 }
2718 
2719 static int ZEND_FASTCALL  ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2720 {
2721         USE_OPLINE
2722         zval *value;
2723         zval *exception;
2724 
2725 
2726         SAVE_OPLINE();
2727         value = opline->op1.zv;
2728 
2729         if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
2730                 if (UNEXPECTED(EG(exception) != NULL)) {
2731                         HANDLE_EXCEPTION();
2732                 }
2733                 zend_error_noreturn(E_ERROR, "Can only throw objects");
2734         }
2735 
2736         zend_exception_save(TSRMLS_C);
2737         /* Not sure if a complete copy is what we want here */
2738         ALLOC_ZVAL(exception);
2739         INIT_PZVAL_COPY(exception, value);
2740         if (!0) {
2741                 zval_copy_ctor(exception);
2742         }
2743 
2744         zend_throw_exception_object(exception TSRMLS_CC);
2745         zend_exception_restore(TSRMLS_C);
2746 
2747         HANDLE_EXCEPTION();
2748 }
2749 
2750 static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2751 {
2752         USE_OPLINE
2753 
2754         SAVE_OPLINE();
2755         if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
2756                 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
2757                         zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.num);
2758                 }
2759         }
2760 
2761         {
2762                 zval *valptr;
2763                 zval *value;
2764 
2765 
2766                 value = opline->op1.zv;
2767 
2768                 ALLOC_ZVAL(valptr);
2769                 INIT_PZVAL_COPY(valptr, value);
2770                 if (!0) {
2771                         zval_copy_ctor(valptr);
2772                 }
2773                 zend_vm_stack_push(valptr TSRMLS_CC);
2774 
2775         }
2776         CHECK_EXCEPTION();
2777         ZEND_VM_NEXT_OPCODE();
2778 }
2779 
2780 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2781 {
2782         USE_OPLINE
2783 
2784         zval *retval = &EX_T(opline->result.var).tmp_var;
2785 
2786         SAVE_OPLINE();
2787         /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
2788         ZVAL_BOOL(retval, i_zend_is_true(opline->op1.zv));
2789 
2790         CHECK_EXCEPTION();
2791         ZEND_VM_NEXT_OPCODE();
2792 }
2793 
2794 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2795 {
2796         USE_OPLINE
2797 
2798         zval *obj;
2799         zend_class_entry *ce;
2800         zend_function *clone;
2801         zend_object_clone_obj_t clone_call;
2802 
2803         SAVE_OPLINE();
2804         obj = opline->op1.zv;
2805 
2806         if (IS_CONST == IS_CONST ||
2807             UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
2808                 if (UNEXPECTED(EG(exception) != NULL)) {
2809                         HANDLE_EXCEPTION();
2810                 }
2811                 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
2812         }
2813 
2814         ce = Z_OBJCE_P(obj);
2815         clone = ce ? ce->clone : NULL;
2816         clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
2817         if (UNEXPECTED(clone_call == NULL)) {
2818                 if (ce) {
2819                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
2820                 } else {
2821                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
2822                 }
2823         }
2824 
2825         if (ce && clone) {
2826                 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
2827                         /* Ensure that if we're calling a private function, we're allowed to do so.
2828                          */
2829                         if (UNEXPECTED(ce != EG(scope))) {
2830                                 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
2831                         }
2832                 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
2833                         /* Ensure that if we're calling a protected function, we're allowed to do so.
2834                          */
2835                         if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
2836                                 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
2837                         }
2838                 }
2839         }
2840 
2841         if (EXPECTED(EG(exception) == NULL)) {
2842                 zval *retval;
2843 
2844                 ALLOC_ZVAL(retval);
2845                 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
2846                 Z_TYPE_P(retval) = IS_OBJECT;
2847                 Z_SET_REFCOUNT_P(retval, 1);
2848                 Z_SET_ISREF_P(retval);
2849                 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
2850                         zval_ptr_dtor(&retval);
2851                 } else {
2852                         EX_T(opline->result.var).var.ptr = retval;
2853                 }
2854         }
2855 
2856         CHECK_EXCEPTION();
2857         ZEND_VM_NEXT_OPCODE();
2858 }
2859 
2860 static int ZEND_FASTCALL  ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2861 {
2862         USE_OPLINE
2863 
2864         zval *expr;
2865         zval *result = &EX_T(opline->result.var).tmp_var;
2866 
2867         SAVE_OPLINE();
2868         expr = opline->op1.zv;
2869 
2870         if (opline->extended_value != IS_STRING) {
2871                 ZVAL_COPY_VALUE(result, expr);
2872                 if (!0) {
2873                         zendi_zval_copy_ctor(*result);
2874                 }
2875         }
2876         switch (opline->extended_value) {
2877                 case IS_NULL:
2878                         convert_to_null(result);
2879                         break;
2880                 case IS_BOOL:
2881                         convert_to_boolean(result);
2882                         break;
2883                 case IS_LONG:
2884                         convert_to_long(result);
2885                         break;
2886                 case IS_DOUBLE:
2887                         convert_to_double(result);
2888                         break;
2889                 case IS_STRING: {
2890                         zval var_copy;
2891                         int use_copy;
2892 
2893                         zend_make_printable_zval(expr, &var_copy, &use_copy);
2894                         if (use_copy) {
2895                                 ZVAL_COPY_VALUE(result, &var_copy);
2896                                 if (0) {
2897 
2898                                 }
2899                         } else {
2900                                 ZVAL_COPY_VALUE(result, expr);
2901                                 if (!0) {
2902                                         zendi_zval_copy_ctor(*result);
2903                                 }
2904                         }
2905                         break;
2906                 }
2907                 case IS_ARRAY:
2908                         convert_to_array(result);
2909                         break;
2910                 case IS_OBJECT:
2911                         convert_to_object(result);
2912                         break;
2913         }
2914 
2915         CHECK_EXCEPTION();
2916         ZEND_VM_NEXT_OPCODE();
2917 }
2918 
2919 static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2920 {
2921         USE_OPLINE
2922         zend_op_array *new_op_array=NULL;
2923 
2924         zval *inc_filename;
2925         zval *tmp_inc_filename = NULL;
2926         zend_bool failure_retval=0;
2927 
2928         SAVE_OPLINE();
2929         inc_filename = opline->op1.zv;
2930 
2931         if (inc_filename->type!=IS_STRING) {
2932                 MAKE_STD_ZVAL(tmp_inc_filename);
2933                 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
2934                 zval_copy_ctor(tmp_inc_filename);
2935                 convert_to_string(tmp_inc_filename);
2936                 inc_filename = tmp_inc_filename;
2937         }
2938 
2939         if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
2940                 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
2941                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
2942                 } else {
2943                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
2944                 }
2945         } else {
2946                 switch (opline->extended_value) {
2947                         case ZEND_INCLUDE_ONCE:
2948                         case ZEND_REQUIRE_ONCE: {
2949                                         zend_file_handle file_handle;
2950                                         char *resolved_path;
2951 
2952                                         resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
2953                                         if (resolved_path) {
2954                                                 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
2955                                         } else {
2956                                                 resolved_path = Z_STRVAL_P(inc_filename);
2957                                         }
2958 
2959                                         if (failure_retval) {
2960                                                 /* do nothing, file already included */
2961                                         } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
2962 
2963                                                 if (!file_handle.opened_path) {
2964                                                         file_handle.opened_path = estrdup(resolved_path);
2965                                                 }
2966 
2967                                                 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
2968                                                         new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
2969                                                         zend_destroy_file_handle(&file_handle TSRMLS_CC);
2970                                                 } else {
2971                                                         zend_file_handle_dtor(&file_handle TSRMLS_CC);
2972                                                         failure_retval=1;
2973                                                 }
2974                                         } else {
2975                                                 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
2976                                                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
2977                                                 } else {
2978                                                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
2979                                                 }
2980                                         }
2981                                         if (resolved_path != Z_STRVAL_P(inc_filename)) {
2982                                                 efree(resolved_path);
2983                                         }
2984                                 }
2985                                 break;
2986                         case ZEND_INCLUDE:
2987                         case ZEND_REQUIRE:
2988                                 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
2989                                 break;
2990                         case ZEND_EVAL: {
2991                                         char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
2992 
2993                                         new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
2994                                         efree(eval_desc);
2995                                 }
2996                                 break;
2997                         EMPTY_SWITCH_DEFAULT_CASE()
2998                 }
2999         }
3000         if (tmp_inc_filename) {
3001                 zval_ptr_dtor(&tmp_inc_filename);
3002         }
3003 
3004         if (UNEXPECTED(EG(exception) != NULL)) {
3005                 HANDLE_EXCEPTION();
3006         } else if (EXPECTED(new_op_array != NULL)) {
3007                 EX(original_return_value) = EG(return_value_ptr_ptr);
3008                 EG(active_op_array) = new_op_array;
3009                 if (RETURN_VALUE_USED(opline)) {
3010                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3011                         EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
3012                 } else {
3013                         EG(return_value_ptr_ptr) = NULL;
3014                 }
3015 
3016                 EX(function_state).function = (zend_function *) new_op_array;
3017                 EX(object) = NULL;
3018 
3019                 if (!EG(active_symbol_table)) {
3020                         zend_rebuild_symbol_table(TSRMLS_C);
3021                 }
3022 
3023                 if (EXPECTED(zend_execute_ex == execute_ex)) {
3024                         ZEND_VM_ENTER();
3025                 } else {
3026                         zend_execute(new_op_array TSRMLS_CC);
3027                 }
3028 
3029                 EX(function_state).function = (zend_function *) EX(op_array);
3030 
3031                 EG(opline_ptr) = &EX(opline);
3032                 EG(active_op_array) = EX(op_array);
3033                 EG(return_value_ptr_ptr) = EX(original_return_value);
3034                 destroy_op_array(new_op_array TSRMLS_CC);
3035                 efree(new_op_array);
3036                 if (UNEXPECTED(EG(exception) != NULL)) {
3037                         zend_throw_exception_internal(NULL TSRMLS_CC);
3038                         HANDLE_EXCEPTION();
3039                 }
3040 
3041         } else if (RETURN_VALUE_USED(opline)) {
3042                 zval *retval;
3043 
3044                 ALLOC_ZVAL(retval);
3045                 ZVAL_BOOL(retval, failure_retval);
3046                 INIT_PZVAL(retval);
3047                 EX_T(opline->result.var).var.ptr = retval;
3048         }
3049         ZEND_VM_NEXT_OPCODE();
3050 }
3051 
3052 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3053 {
3054         USE_OPLINE
3055 
3056         zval *array_ptr, **array_ptr_ptr;
3057         HashTable *fe_ht;
3058         zend_object_iterator *iter = NULL;
3059         zend_class_entry *ce = NULL;
3060         zend_bool is_empty = 0;
3061 
3062         SAVE_OPLINE();
3063 
3064         if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
3065             (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
3066                 array_ptr_ptr = NULL;
3067                 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
3068                         MAKE_STD_ZVAL(array_ptr);
3069                         ZVAL_NULL(array_ptr);
3070                 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
3071                         if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
3072                                 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
3073                                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
3074                         }
3075 
3076                         ce = Z_OBJCE_PP(array_ptr_ptr);
3077                         if (!ce || ce->get_iterator == NULL) {
3078                                 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
3079                                 Z_ADDREF_PP(array_ptr_ptr);
3080                         }
3081                         array_ptr = *array_ptr_ptr;
3082                 } else {
3083                         if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
3084                                 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
3085                                 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
3086                                         Z_SET_ISREF_PP(array_ptr_ptr);
3087                                 }
3088                         }
3089                         array_ptr = *array_ptr_ptr;
3090                         Z_ADDREF_P(array_ptr);
3091                 }
3092         } else {
3093                 array_ptr = opline->op1.zv;
3094                 if (0) { /* IS_TMP_VAR */
3095                         zval *tmp;
3096 
3097                         ALLOC_ZVAL(tmp);
3098                         INIT_PZVAL_COPY(tmp, array_ptr);
3099                         array_ptr = tmp;
3100                         if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
3101                                 ce = Z_OBJCE_P(array_ptr);
3102                                 if (ce && ce->get_iterator) {
3103                                         Z_DELREF_P(array_ptr);
3104                                 }
3105                         }
3106                 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
3107                         ce = Z_OBJCE_P(array_ptr);
3108                         if (!ce || !ce->get_iterator) {
3109                                 if (IS_CONST == IS_CV) {
3110                                         Z_ADDREF_P(array_ptr);
3111                                 }
3112                         }
3113                 } else if (IS_CONST == IS_CONST ||
3114                            (IS_CONST == IS_CV &&
3115                             !Z_ISREF_P(array_ptr) &&
3116                             Z_REFCOUNT_P(array_ptr) > 1) ||
3117                            (IS_CONST == IS_VAR &&
3118                             !Z_ISREF_P(array_ptr) &&
3119                             Z_REFCOUNT_P(array_ptr) > 2)) {
3120                         zval *tmp;
3121 
3122                         if (IS_CONST == IS_VAR) {
3123                                 Z_DELREF_P(array_ptr);
3124                         }
3125                         ALLOC_ZVAL(tmp);
3126                         INIT_PZVAL_COPY(tmp, array_ptr);
3127                         zval_copy_ctor(tmp);
3128                         array_ptr = tmp;
3129                 } else if (IS_CONST == IS_CV) {
3130                         Z_ADDREF_P(array_ptr);
3131                 }
3132         }
3133 
3134         if (ce && ce->get_iterator) {
3135                 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
3136 
3137                 if (IS_CONST == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
3138 
3139                 }
3140                 if (iter && EXPECTED(EG(exception) == NULL)) {
3141                         array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
3142                 } else {
3143                         if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
3144 
3145                         }
3146                         if (!EG(exception)) {
3147                                 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
3148                         }
3149                         zend_throw_exception_internal(NULL TSRMLS_CC);
3150                         HANDLE_EXCEPTION();
3151                 }
3152         }
3153 
3154         EX_T(opline->result.var).fe.ptr = array_ptr;
3155 
3156         if (iter) {
3157                 iter->index = 0;
3158                 if (iter->funcs->rewind) {
3159                         iter->funcs->rewind(iter TSRMLS_CC);
3160                         if (UNEXPECTED(EG(exception) != NULL)) {
3161                                 zval_ptr_dtor(&array_ptr);
3162                                 if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
3163 
3164                                 }
3165                                 HANDLE_EXCEPTION();
3166                         }
3167                 }
3168                 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
3169                 if (UNEXPECTED(EG(exception) != NULL)) {
3170                         zval_ptr_dtor(&array_ptr);
3171                         if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
3172 
3173                         }
3174                         HANDLE_EXCEPTION();
3175                 }
3176                 iter->index = -1; /* will be set to 0 before using next handler */
3177         } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
3178                 zend_hash_internal_pointer_reset(fe_ht);
3179                 if (ce) {
3180                         zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
3181                         while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
3182                                 char *str_key;
3183                                 uint str_key_len;
3184                                 ulong int_key;
3185                                 zend_uchar key_type;
3186 
3187                                 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
3188                                 if (key_type != HASH_KEY_NON_EXISTENT &&
3189                                         (key_type == HASH_KEY_IS_LONG ||
3190                                      zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
3191                                         break;
3192                                 }
3193                                 zend_hash_move_forward(fe_ht);
3194                         }
3195                 }
3196                 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
3197                 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
3198         } else {
3199                 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
3200                 is_empty = 1;
3201         }
3202 
3203         if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
3204 
3205         }
3206         if (is_empty) {
3207                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
3208         } else {
3209                 CHECK_EXCEPTION();
3210                 ZEND_VM_NEXT_OPCODE();
3211         }
3212 }
3213 
3214 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3215 {
3216 #if 0 || (IS_CONST != IS_UNUSED)
3217         USE_OPLINE
3218 
3219         SAVE_OPLINE();
3220         if (IS_CONST != IS_UNUSED) {
3221 
3222                 zval *ptr = opline->op1.zv;
3223 
3224                 if (Z_TYPE_P(ptr) == IS_LONG) {
3225                         EG(exit_status) = Z_LVAL_P(ptr);
3226                 } else {
3227                         zend_print_variable(ptr);
3228                 }
3229 
3230         }
3231 #endif
3232         zend_bailout();
3233         ZEND_VM_NEXT_OPCODE(); /* Never reached */
3234 }
3235 
3236 static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3237 {
3238         USE_OPLINE
3239 
3240         zval *value;
3241 
3242         SAVE_OPLINE();
3243         value = opline->op1.zv;
3244 
3245         if (i_zend_is_true(value)) {
3246                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
3247                 if (!0) {
3248                         zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
3249                 }
3250 
3251 #if DEBUG_ZEND>=2
3252                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
3253 #endif
3254                 ZEND_VM_JMP(opline->op2.jmp_addr);
3255         }
3256 
3257         CHECK_EXCEPTION();
3258         ZEND_VM_NEXT_OPCODE();
3259 }
3260 
3261 static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3262 {
3263         USE_OPLINE
3264 
3265         zval *value, *ret;
3266 
3267         SAVE_OPLINE();
3268         value = opline->op1.zv;
3269 
3270         if (i_zend_is_true(value)) {
3271                 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
3272                         Z_ADDREF_P(value);
3273                         EX_T(opline->result.var).var.ptr = value;
3274                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3275                 } else {
3276                         ALLOC_ZVAL(ret);
3277                         INIT_PZVAL_COPY(ret, value);
3278                         EX_T(opline->result.var).var.ptr = ret;
3279                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3280                         if (!0) {
3281                                 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
3282                         }
3283                 }
3284 
3285 #if DEBUG_ZEND>=2
3286                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
3287 #endif
3288                 ZEND_VM_JMP(opline->op2.jmp_addr);
3289         }
3290 
3291         CHECK_EXCEPTION();
3292         ZEND_VM_NEXT_OPCODE();
3293 }
3294 
3295 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3296 {
3297         USE_OPLINE
3298 
3299         zval *value;
3300 
3301         SAVE_OPLINE();
3302         value = opline->op1.zv;
3303 
3304         ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
3305         if (!0) {
3306                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
3307         }
3308 
3309         CHECK_EXCEPTION();
3310         ZEND_VM_NEXT_OPCODE();
3311 }
3312 
3313 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3314 {
3315         USE_OPLINE
3316 
3317         zval *value, *ret;
3318 
3319         SAVE_OPLINE();
3320         value = opline->op1.zv;
3321 
3322         if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
3323                 Z_ADDREF_P(value);
3324                 EX_T(opline->result.var).var.ptr = value;
3325                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3326         } else {
3327                 ALLOC_ZVAL(ret);
3328                 INIT_PZVAL_COPY(ret, value);
3329                 EX_T(opline->result.var).var.ptr = ret;
3330                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
3331                 if (!0) {
3332                         zval_copy_ctor(EX_T(opline->result.var).var.ptr);
3333                 }
3334         }
3335 
3336         CHECK_EXCEPTION();
3337         ZEND_VM_NEXT_OPCODE();
3338 }
3339 
3340 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3341 {
3342         USE_OPLINE
3343 
3344 
3345         SAVE_OPLINE();
3346         fast_add_function(&EX_T(opline->result.var).tmp_var,
3347                 opline->op1.zv,
3348                 opline->op2.zv TSRMLS_CC);
3349 
3350 
3351         CHECK_EXCEPTION();
3352         ZEND_VM_NEXT_OPCODE();
3353 }
3354 
3355 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3356 {
3357         USE_OPLINE
3358 
3359 
3360         SAVE_OPLINE();
3361         fast_sub_function(&EX_T(opline->result.var).tmp_var,
3362                 opline->op1.zv,
3363                 opline->op2.zv TSRMLS_CC);
3364 
3365 
3366         CHECK_EXCEPTION();
3367         ZEND_VM_NEXT_OPCODE();
3368 }
3369 
3370 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3371 {
3372         USE_OPLINE
3373 
3374 
3375         SAVE_OPLINE();
3376         fast_mul_function(&EX_T(opline->result.var).tmp_var,
3377                 opline->op1.zv,
3378                 opline->op2.zv TSRMLS_CC);
3379 
3380 
3381         CHECK_EXCEPTION();
3382         ZEND_VM_NEXT_OPCODE();
3383 }
3384 
3385 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3386 {
3387         USE_OPLINE
3388 
3389 
3390         SAVE_OPLINE();
3391         fast_div_function(&EX_T(opline->result.var).tmp_var,
3392                 opline->op1.zv,
3393                 opline->op2.zv TSRMLS_CC);
3394 
3395 
3396         CHECK_EXCEPTION();
3397         ZEND_VM_NEXT_OPCODE();
3398 }
3399 
3400 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3401 {
3402         USE_OPLINE
3403 
3404 
3405         SAVE_OPLINE();
3406         fast_mod_function(&EX_T(opline->result.var).tmp_var,
3407                 opline->op1.zv,
3408                 opline->op2.zv TSRMLS_CC);
3409 
3410 
3411         CHECK_EXCEPTION();
3412         ZEND_VM_NEXT_OPCODE();
3413 }
3414 
3415 static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3416 {
3417         USE_OPLINE
3418 
3419 
3420         SAVE_OPLINE();
3421         shift_left_function(&EX_T(opline->result.var).tmp_var,
3422                 opline->op1.zv,
3423                 opline->op2.zv TSRMLS_CC);
3424 
3425 
3426         CHECK_EXCEPTION();
3427         ZEND_VM_NEXT_OPCODE();
3428 }
3429 
3430 static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3431 {
3432         USE_OPLINE
3433 
3434 
3435         SAVE_OPLINE();
3436         shift_right_function(&EX_T(opline->result.var).tmp_var,
3437                 opline->op1.zv,
3438                 opline->op2.zv TSRMLS_CC);
3439 
3440 
3441         CHECK_EXCEPTION();
3442         ZEND_VM_NEXT_OPCODE();
3443 }
3444 
3445 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3446 {
3447         USE_OPLINE
3448 
3449 
3450         SAVE_OPLINE();
3451         concat_function(&EX_T(opline->result.var).tmp_var,
3452                 opline->op1.zv,
3453                 opline->op2.zv TSRMLS_CC);
3454 
3455 
3456         CHECK_EXCEPTION();
3457         ZEND_VM_NEXT_OPCODE();
3458 }
3459 
3460 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3461 {
3462         USE_OPLINE
3463 
3464 
3465         SAVE_OPLINE();
3466         is_identical_function(&EX_T(opline->result.var).tmp_var,
3467                 opline->op1.zv,
3468                 opline->op2.zv TSRMLS_CC);
3469 
3470 
3471         CHECK_EXCEPTION();
3472         ZEND_VM_NEXT_OPCODE();
3473 }
3474 
3475 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3476 {
3477         USE_OPLINE
3478 
3479         zval *result = &EX_T(opline->result.var).tmp_var;
3480 
3481         SAVE_OPLINE();
3482         is_identical_function(result,
3483                 opline->op1.zv,
3484                 opline->op2.zv TSRMLS_CC);
3485         Z_LVAL_P(result) = !Z_LVAL_P(result);
3486 
3487 
3488         CHECK_EXCEPTION();
3489         ZEND_VM_NEXT_OPCODE();
3490 }
3491 
3492 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3493 {
3494         USE_OPLINE
3495 
3496         zval *result = &EX_T(opline->result.var).tmp_var;
3497 
3498         SAVE_OPLINE();
3499         ZVAL_BOOL(result, fast_equal_function(result,
3500                 opline->op1.zv,
3501                 opline->op2.zv TSRMLS_CC));
3502 
3503 
3504         CHECK_EXCEPTION();
3505         ZEND_VM_NEXT_OPCODE();
3506 }
3507 
3508 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3509 {
3510         USE_OPLINE
3511 
3512         zval *result = &EX_T(opline->result.var).tmp_var;
3513 
3514         SAVE_OPLINE();
3515         ZVAL_BOOL(result, fast_not_equal_function(result,
3516                 opline->op1.zv,
3517                 opline->op2.zv TSRMLS_CC));
3518 
3519 
3520         CHECK_EXCEPTION();
3521         ZEND_VM_NEXT_OPCODE();
3522 }
3523 
3524 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3525 {
3526         USE_OPLINE
3527 
3528         zval *result = &EX_T(opline->result.var).tmp_var;
3529 
3530         SAVE_OPLINE();
3531         ZVAL_BOOL(result, fast_is_smaller_function(result,
3532                 opline->op1.zv,
3533                 opline->op2.zv TSRMLS_CC));
3534 
3535 
3536         CHECK_EXCEPTION();
3537         ZEND_VM_NEXT_OPCODE();
3538 }
3539 
3540 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3541 {
3542         USE_OPLINE
3543 
3544         zval *result = &EX_T(opline->result.var).tmp_var;
3545 
3546         SAVE_OPLINE();
3547         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
3548                 opline->op1.zv,
3549                 opline->op2.zv TSRMLS_CC));
3550 
3551 
3552         CHECK_EXCEPTION();
3553         ZEND_VM_NEXT_OPCODE();
3554 }
3555 
3556 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3557 {
3558         USE_OPLINE
3559 
3560 
3561         SAVE_OPLINE();
3562         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
3563                 opline->op1.zv,
3564                 opline->op2.zv TSRMLS_CC);
3565 
3566 
3567         CHECK_EXCEPTION();
3568         ZEND_VM_NEXT_OPCODE();
3569 }
3570 
3571 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3572 {
3573         USE_OPLINE
3574 
3575 
3576         SAVE_OPLINE();
3577         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
3578                 opline->op1.zv,
3579                 opline->op2.zv TSRMLS_CC);
3580 
3581 
3582         CHECK_EXCEPTION();
3583         ZEND_VM_NEXT_OPCODE();
3584 }
3585 
3586 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3587 {
3588         USE_OPLINE
3589 
3590 
3591         SAVE_OPLINE();
3592         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
3593                 opline->op1.zv,
3594                 opline->op2.zv TSRMLS_CC);
3595 
3596 
3597         CHECK_EXCEPTION();
3598         ZEND_VM_NEXT_OPCODE();
3599 }
3600 
3601 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3602 {
3603         USE_OPLINE
3604 
3605 
3606         SAVE_OPLINE();
3607         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
3608                 opline->op1.zv,
3609                 opline->op2.zv TSRMLS_CC);
3610 
3611 
3612         CHECK_EXCEPTION();
3613         ZEND_VM_NEXT_OPCODE();
3614 }
3615 
3616 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
3617 {
3618         USE_OPLINE
3619         zend_free_op free_op1;
3620         zval *varname;
3621         zval **retval;
3622         zval tmp_varname;
3623         HashTable *target_symbol_table;
3624         ulong hash_value;
3625 
3626         SAVE_OPLINE();
3627         varname = opline->op1.zv;
3628 
3629         if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
3630                 ZVAL_COPY_VALUE(&tmp_varname, varname);
3631                 zval_copy_ctor(&tmp_varname);
3632                 Z_SET_REFCOUNT(tmp_varname, 1);
3633                 Z_UNSET_ISREF(tmp_varname);
3634                 convert_to_string(&tmp_varname);
3635                 varname = &tmp_varname;
3636         }
3637 
3638         if (IS_CONST != IS_UNUSED) {
3639                 zend_class_entry *ce;
3640 
3641                 if (IS_CONST == IS_CONST) {
3642                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
3643                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
3644                         } else {
3645                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
3646                                 if (UNEXPECTED(ce == NULL)) {
3647                                         if (IS_CONST != IS_CONST && varname == &tmp_varname) {
3648                                                 zval_dtor(&tmp_varname);
3649                                         }
3650 
3651                                         CHECK_EXCEPTION();
3652                                         ZEND_VM_NEXT_OPCODE();
3653                                 }
3654                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
3655                         }
3656                 } else {
3657                         ce = EX_T(opline->op2.var).class_entry;
3658                 }
3659                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
3660 
3661         } else {
3662                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
3663 /*
3664                 if (!target_symbol_table) {
3665                         CHECK_EXCEPTION();
3666                         ZEND_VM_NEXT_OPCODE();
3667                 }
3668 */
3669                 if (IS_CONST == IS_CONST) {
3670                         hash_value = Z_HASH_P(varname);
3671                 } else {
3672                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
3673                 }
3674 
3675                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
3676                         switch (type) {
3677                                 case BP_VAR_R:
3678                                 case BP_VAR_UNSET:
3679                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
3680                                         /* break missing intentionally */
3681                                 case BP_VAR_IS:
3682                                         retval = &EG(uninitialized_zval_ptr);
3683                                         break;
3684                                 case BP_VAR_RW:
3685                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
3686                                         /* break missing intentionally */
3687                                 case BP_VAR_W:
3688                                         Z_ADDREF_P(&EG(uninitialized_zval));
3689                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
3690                                         break;
3691                                 EMPTY_SWITCH_DEFAULT_CASE()
3692                         }
3693                 }
3694                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
3695                         case ZEND_FETCH_GLOBAL:
3696                                 if (IS_CONST != IS_TMP_VAR) {
3697 
3698                                 }
3699                                 break;
3700                         case ZEND_FETCH_LOCAL:
3701 
3702                                 break;
3703                         case ZEND_FETCH_STATIC:
3704                                 zval_update_constant(retval, 1 TSRMLS_CC);
3705                                 break;
3706                         case ZEND_FETCH_GLOBAL_LOCK:
3707                                 if (IS_CONST == IS_VAR && !free_op1.var) {
3708                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
3709                                 }
3710                                 break;
3711                 }
3712         }
3713 
3714 
3715         if (IS_CONST != IS_CONST && varname == &tmp_varname) {
3716                 zval_dtor(&tmp_varname);
3717         }
3718         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
3719                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
3720         }
3721         PZVAL_LOCK(*retval);
3722         switch (type) {
3723                 case BP_VAR_R:
3724                 case BP_VAR_IS:
3725                         EX_T(opline->result.var).var.ptr = *retval;
3726                         break;
3727                 case BP_VAR_UNSET: {
3728                         zend_free_op free_res;
3729 
3730                         PZVAL_UNLOCK(*retval, &free_res);
3731                         if (retval != &EG(uninitialized_zval_ptr)) {
3732                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
3733                         }
3734                         PZVAL_LOCK(*retval);
3735                         FREE_OP_VAR_PTR(free_res);
3736                 }
3737                 /* break missing intentionally */
3738                 default:
3739                         EX_T(opline->result.var).var.ptr_ptr = retval;
3740                         break;
3741         }
3742         CHECK_EXCEPTION();
3743         ZEND_VM_NEXT_OPCODE();
3744 }
3745 
3746 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3747 {
3748         return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3749 }
3750 
3751 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3752 {
3753         return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3754 }
3755 
3756 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3757 {
3758         return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3759 }
3760 
3761 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3762 {
3763         USE_OPLINE
3764 
3765         return zend_fetch_var_address_helper_SPEC_CONST_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3766 }
3767 
3768 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3769 {
3770         return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3771 }
3772 
3773 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3774 {
3775         return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
3776 }
3777 
3778 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3779 {
3780         USE_OPLINE
3781 
3782         zval *container;
3783 
3784         SAVE_OPLINE();
3785         container = opline->op1.zv;
3786         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
3787 
3788         if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
3789 
3790         }
3791         CHECK_EXCEPTION();
3792         ZEND_VM_NEXT_OPCODE();
3793 }
3794 
3795 static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3796 {
3797         USE_OPLINE
3798 
3799         zval *container;
3800 
3801         SAVE_OPLINE();
3802         container = opline->op1.zv;
3803 
3804         if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
3805                 PZVAL_LOCK(&EG(uninitialized_zval));
3806                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
3807         } else {
3808 
3809                 zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
3810 
3811                 PZVAL_LOCK(value);
3812                 EX_T(opline->result.var).var.ptr = value;
3813 
3814         }
3815         CHECK_EXCEPTION();
3816         ZEND_VM_NEXT_OPCODE();
3817 }
3818 
3819 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3820 {
3821         USE_OPLINE
3822         zval *function_name;
3823         zend_class_entry *ce;
3824         call_slot *call = EX(call_slots) + opline->result.num;
3825 
3826         SAVE_OPLINE();
3827 
3828         if (IS_CONST == IS_CONST) {
3829                 /* no function found. try a static method in class */
3830                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
3831                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
3832                 } else {
3833                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
3834                         if (UNEXPECTED(EG(exception) != NULL)) {
3835                                 HANDLE_EXCEPTION();
3836                         }
3837                         if (UNEXPECTED(ce == NULL)) {
3838                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
3839                         }
3840                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
3841                 }
3842                 call->called_scope = ce;
3843         } else {
3844                 ce = EX_T(opline->op1.var).class_entry;
3845 
3846                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
3847                         call->called_scope = EG(called_scope);
3848                 } else {
3849                         call->called_scope = ce;
3850                 }
3851         }
3852 
3853         if (IS_CONST == IS_CONST &&
3854             IS_CONST == IS_CONST &&
3855             CACHED_PTR(opline->op2.literal->cache_slot)) {
3856                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
3857         } else if (IS_CONST != IS_CONST &&
3858                    IS_CONST == IS_CONST &&
3859                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
3860                 /* do nothing */
3861         } else if (IS_CONST != IS_UNUSED) {
3862                 char *function_name_strval = NULL;
3863                 int function_name_strlen = 0;
3864 
3865 
3866                 if (IS_CONST == IS_CONST) {
3867                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
3868                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
3869                 } else {
3870                         function_name = opline->op2.zv;
3871 
3872                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
3873                                 if (UNEXPECTED(EG(exception) != NULL)) {
3874                                         HANDLE_EXCEPTION();
3875                                 }
3876                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
3877                         } else {
3878                                 function_name_strval = Z_STRVAL_P(function_name);
3879                                 function_name_strlen = Z_STRLEN_P(function_name);
3880                         }
3881                 }
3882 
3883                 if (function_name_strval) {
3884                         if (ce->get_static_method) {
3885                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
3886                         } else {
3887                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
3888                         }
3889                         if (UNEXPECTED(call->fbc == NULL)) {
3890                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
3891                         }
3892                         if (IS_CONST == IS_CONST &&
3893                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
3894                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
3895                                 if (IS_CONST == IS_CONST) {
3896                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
3897                                 } else {
3898                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
3899                                 }
3900                         }
3901                 }
3902                 if (IS_CONST != IS_CONST) {
3903 
3904                 }
3905         } else {
3906                 if (UNEXPECTED(ce->constructor == NULL)) {
3907                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
3908                 }
3909                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
3910                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
3911                 }
3912                 call->fbc = ce->constructor;
3913         }
3914 
3915         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
3916                 call->object = NULL;
3917         } else {
3918                 if (EG(This) &&
3919                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
3920                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
3921                     /* We are calling method of the other (incompatible) class,
3922                        but passing $this. This is done for compatibility with php-4. */
3923                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
3924                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
3925                         } else {
3926                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
3927                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
3928                         }
3929                 }
3930                 if ((call->object = EG(This))) {
3931                         Z_ADDREF_P(call->object);
3932                         call->called_scope = Z_OBJCE_P(call->object);
3933                 }
3934         }
3935 
3936         call->num_additional_args = 0;
3937         call->is_ctor_call = 0;
3938         EX(call) = call;
3939 
3940         CHECK_EXCEPTION();
3941         ZEND_VM_NEXT_OPCODE();
3942 }
3943 
3944 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3945 {
3946         USE_OPLINE
3947 
3948 
3949         SAVE_OPLINE();
3950         is_equal_function(&EX_T(opline->result.var).tmp_var,
3951                                  opline->op1.zv,
3952                                  opline->op2.zv TSRMLS_CC);
3953 
3954         CHECK_EXCEPTION();
3955         ZEND_VM_NEXT_OPCODE();
3956 }
3957 
3958 static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3959 {
3960         USE_OPLINE
3961 
3962         SAVE_OPLINE();
3963         if (IS_CONST == IS_UNUSED) {
3964                 zend_constant *c;
3965                 zval *retval;
3966 
3967                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
3968                         c = CACHED_PTR(opline->op2.literal->cache_slot);
3969                 } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
3970                         if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
3971                                 char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
3972                                 if(!actual) {
3973                                         actual = Z_STRVAL_P(opline->op2.zv);
3974                                 } else {
3975                                         actual++;
3976                                 }
3977                                 /* non-qualified constant - allow text substitution */
3978                                 zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
3979                                 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
3980                                 CHECK_EXCEPTION();
3981                                 ZEND_VM_NEXT_OPCODE();
3982                         } else {
3983                                 zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
3984                         }
3985                 } else {
3986                         CACHE_PTR(opline->op2.literal->cache_slot, c);
3987                 }
3988                 retval = &EX_T(opline->result.var).tmp_var;
3989                 ZVAL_COPY_VALUE(retval, &c->value);
3990                 zval_copy_ctor(retval);
3991         } else {
3992                 /* class constant */
3993                 zend_class_entry *ce;
3994                 zval **value;
3995 
3996                 if (IS_CONST == IS_CONST) {
3997                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
3998                                 value = CACHED_PTR(opline->op2.literal->cache_slot);
3999                                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
4000                                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
4001                                 goto constant_fetch_end;
4002                         } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
4003                                 ce = CACHED_PTR(opline->op1.literal->cache_slot);
4004                         } else {
4005                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
4006                                 if (UNEXPECTED(EG(exception) != NULL)) {
4007                                         HANDLE_EXCEPTION();
4008                                 }
4009                                 if (UNEXPECTED(ce == NULL)) {
4010                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
4011                                 }
4012                                 CACHE_PTR(opline->op1.literal->cache_slot, ce);
4013                         }
4014                 } else {
4015                         ce = EX_T(opline->op1.var).class_entry;
4016                         if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
4017                                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
4018                                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
4019                                 goto constant_fetch_end;
4020                         }
4021                 }
4022 
4023                 if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
4024                         if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
4025                                 zend_class_entry *old_scope = EG(scope);
4026 
4027                                 EG(scope) = ce;
4028                                 zval_update_constant(value, 1 TSRMLS_CC);
4029                                 EG(scope) = old_scope;
4030                         }
4031                         if (IS_CONST == IS_CONST) {
4032                                 CACHE_PTR(opline->op2.literal->cache_slot, value);
4033                         } else {
4034                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
4035                         }
4036                         ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
4037                         zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
4038                 } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
4039                         /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
4040                         ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
4041                 } else {
4042                         zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
4043                 }
4044         }
4045 constant_fetch_end:
4046         CHECK_EXCEPTION();
4047         ZEND_VM_NEXT_OPCODE();
4048 }
4049 
4050 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4051 {
4052         USE_OPLINE
4053 
4054         zval *expr_ptr;
4055 
4056         SAVE_OPLINE();
4057         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
4058                 zval **expr_ptr_ptr = NULL;
4059 
4060                 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
4061                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
4062                 }
4063                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
4064                 expr_ptr = *expr_ptr_ptr;
4065                 Z_ADDREF_P(expr_ptr);
4066         } else {
4067                 expr_ptr=opline->op1.zv;
4068                 if (0) { /* temporary variable */
4069                         zval *new_expr;
4070 
4071                         ALLOC_ZVAL(new_expr);
4072                         INIT_PZVAL_COPY(new_expr, expr_ptr);
4073                         expr_ptr = new_expr;
4074                 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
4075                         zval *new_expr;
4076 
4077                         ALLOC_ZVAL(new_expr);
4078                         INIT_PZVAL_COPY(new_expr, expr_ptr);
4079                         expr_ptr = new_expr;
4080                         zendi_zval_copy_ctor(*expr_ptr);
4081 
4082                 } else if (IS_CONST == IS_CV) {
4083                         Z_ADDREF_P(expr_ptr);
4084                 }
4085         }
4086 
4087         if (IS_CONST != IS_UNUSED) {
4088 
4089                 zval *offset = opline->op2.zv;
4090                 ulong hval;
4091 
4092                 switch (Z_TYPE_P(offset)) {
4093                         case IS_DOUBLE:
4094                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
4095                                 goto num_index;
4096                         case IS_LONG:
4097                         case IS_BOOL:
4098                                 hval = Z_LVAL_P(offset);
4099 num_index:
4100                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
4101                                 break;
4102                         case IS_STRING:
4103                                 if (IS_CONST == IS_CONST) {
4104                                         hval = Z_HASH_P(offset);
4105                                 } else {
4106                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
4107                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
4108                                 }
4109                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
4110                                 break;
4111                         case IS_NULL:
4112                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
4113                                 break;
4114                         default:
4115                                 zend_error(E_WARNING, "Illegal offset type");
4116                                 zval_ptr_dtor(&expr_ptr);
4117                                 /* do nothing */
4118                                 break;
4119                 }
4120 
4121         } else {
4122                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
4123         }
4124         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
4125 
4126         }
4127         CHECK_EXCEPTION();
4128         ZEND_VM_NEXT_OPCODE();
4129 }
4130 
4131 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4132 {
4133         USE_OPLINE
4134 
4135         array_init(&EX_T(opline->result.var).tmp_var);
4136         if (IS_CONST == IS_UNUSED) {
4137                 ZEND_VM_NEXT_OPCODE();
4138 #if 0 || IS_CONST != IS_UNUSED
4139         } else {
4140                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
4141 #endif
4142         }
4143 }
4144 
4145 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4146 {
4147         USE_OPLINE
4148         zval tmp, *varname;
4149         HashTable *target_symbol_table;
4150 
4151 
4152         SAVE_OPLINE();
4153         if (IS_CONST == IS_CV &&
4154             IS_CONST == IS_UNUSED &&
4155             (opline->extended_value & ZEND_QUICK_SET)) {
4156                 if (EG(active_symbol_table)) {
4157                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
4158 
4159                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
4160                         EX_CV(opline->op1.var) = NULL;
4161                 } else if (EX_CV(opline->op1.var)) {
4162                         zval_ptr_dtor(EX_CV(opline->op1.var));
4163                         EX_CV(opline->op1.var) = NULL;
4164                 }
4165                 CHECK_EXCEPTION();
4166                 ZEND_VM_NEXT_OPCODE();
4167         }
4168 
4169         varname = opline->op1.zv;
4170 
4171         if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
4172                 ZVAL_COPY_VALUE(&tmp, varname);
4173                 zval_copy_ctor(&tmp);
4174                 convert_to_string(&tmp);
4175                 varname = &tmp;
4176         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
4177                 Z_ADDREF_P(varname);
4178         }
4179 
4180         if (IS_CONST != IS_UNUSED) {
4181                 zend_class_entry *ce;
4182 
4183                 if (IS_CONST == IS_CONST) {
4184                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
4185                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
4186                         } else {
4187                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
4188                                 if (UNEXPECTED(EG(exception) != NULL)) {
4189                                         if (IS_CONST != IS_CONST && varname == &tmp) {
4190                                                 zval_dtor(&tmp);
4191                                         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
4192                                                 zval_ptr_dtor(&varname);
4193                                         }
4194 
4195                                         HANDLE_EXCEPTION();
4196                                 }
4197                                 if (UNEXPECTED(ce == NULL)) {
4198                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
4199                                 }
4200                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
4201                         }
4202                 } else {
4203                         ce = EX_T(opline->op2.var).class_entry;
4204                 }
4205                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
4206         } else {
4207                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
4208 
4209                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
4210                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
4211         }
4212 
4213         if (IS_CONST != IS_CONST && varname == &tmp) {
4214                 zval_dtor(&tmp);
4215         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
4216                 zval_ptr_dtor(&varname);
4217         }
4218 
4219         CHECK_EXCEPTION();
4220         ZEND_VM_NEXT_OPCODE();
4221 }
4222 
4223 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4224 {
4225         USE_OPLINE
4226         zval **value;
4227         zend_bool isset = 1;
4228 
4229         SAVE_OPLINE();
4230         if (IS_CONST == IS_CV &&
4231             IS_CONST == IS_UNUSED &&
4232             (opline->extended_value & ZEND_QUICK_SET)) {
4233                 if (EX_CV(opline->op1.var)) {
4234                         value = EX_CV(opline->op1.var);
4235                 } else if (EG(active_symbol_table)) {
4236                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
4237 
4238                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
4239                                 isset = 0;
4240                         }
4241                 } else {
4242                         isset = 0;
4243                 }
4244         } else {
4245                 HashTable *target_symbol_table;
4246 
4247                 zval tmp, *varname = opline->op1.zv;
4248 
4249                 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
4250                         ZVAL_COPY_VALUE(&tmp, varname);
4251                         zval_copy_ctor(&tmp);
4252                         convert_to_string(&tmp);
4253                         varname = &tmp;
4254                 }
4255 
4256                 if (IS_CONST != IS_UNUSED) {
4257                         zend_class_entry *ce;
4258 
4259                         if (IS_CONST == IS_CONST) {
4260                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
4261                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
4262                                 } else {
4263                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
4264                                         if (UNEXPECTED(ce == NULL)) {
4265                                                 CHECK_EXCEPTION();
4266                                                 ZEND_VM_NEXT_OPCODE();
4267                                         }
4268                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
4269                                 }
4270                         } else {
4271                                 ce = EX_T(opline->op2.var).class_entry;
4272                         }
4273                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
4274                         if (!value) {
4275                                 isset = 0;
4276                         }
4277                 } else {
4278                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
4279                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
4280                                 isset = 0;
4281                         }
4282                 }
4283 
4284                 if (IS_CONST != IS_CONST && varname == &tmp) {
4285                         zval_dtor(&tmp);
4286                 }
4287 
4288         }
4289 
4290         if (opline->extended_value & ZEND_ISSET) {
4291                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
4292                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
4293                 } else {
4294                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
4295                 }
4296         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
4297                 if (!isset || !i_zend_is_true(*value)) {
4298                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
4299                 } else {
4300                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
4301                 }
4302         }
4303 
4304         CHECK_EXCEPTION();
4305         ZEND_VM_NEXT_OPCODE();
4306 }
4307 
4308 static int ZEND_FASTCALL  ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4309 {
4310         USE_OPLINE
4311 
4312         zval *name;
4313         zval *val;
4314         zend_constant c;
4315 
4316         SAVE_OPLINE();
4317         name  = opline->op1.zv;
4318         val   = opline->op2.zv;
4319 
4320         if (IS_CONSTANT_TYPE(Z_TYPE_P(val))) {
4321                 zval tmp;
4322                 zval *tmp_ptr = &tmp;
4323 
4324                 ZVAL_COPY_VALUE(&tmp, val);
4325                 INIT_PZVAL(&tmp);
4326                 zval_update_constant(&tmp_ptr, 0 TSRMLS_CC);
4327                 c.value = *tmp_ptr;
4328         } else {
4329                 INIT_PZVAL_COPY(&c.value, val);
4330                 if (Z_TYPE(c.value) == IS_ARRAY) {
4331                         HashTable *ht;
4332 
4333                         ALLOC_HASHTABLE(ht);
4334                         zend_hash_init(ht, zend_hash_num_elements(Z_ARRVAL(c.value)), NULL, ZVAL_PTR_DTOR, 0);
4335                         zend_hash_copy(ht, Z_ARRVAL(c.value), (copy_ctor_func_t) zval_deep_copy, NULL, sizeof(zval *));
4336                         Z_ARRVAL(c.value) = ht;
4337                 } else {
4338                         zval_copy_ctor(&c.value);
4339                 }
4340         }
4341         c.flags = CONST_CS; /* non persistent, case sensetive */
4342         c.name = str_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
4343         c.name_len = Z_STRLEN_P(name)+1;
4344         c.module_number = PHP_USER_CONSTANT;
4345 
4346         if (zend_register_constant(&c TSRMLS_CC) == FAILURE) {
4347         }
4348 
4349 
4350         CHECK_EXCEPTION();
4351         ZEND_VM_NEXT_OPCODE();
4352 }
4353 
4354 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4355 {
4356         USE_OPLINE
4357 
4358         /* The generator object is stored in return_value_ptr_ptr */
4359         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
4360 
4361         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
4362                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
4363         }
4364 
4365         /* Destroy the previously yielded value */
4366         if (generator->value) {
4367                 zval_ptr_dtor(&generator->value);
4368         }
4369 
4370         /* Destroy the previously yielded key */
4371         if (generator->key) {
4372                 zval_ptr_dtor(&generator->key);
4373         }
4374 
4375         /* Set the new yielded value */
4376         if (IS_CONST != IS_UNUSED) {
4377 
4378 
4379                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
4380                         /* Constants and temporary variables aren't yieldable by reference,
4381                          * but we still allow them with a notice. */
4382                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
4383                                 zval *value, *copy;
4384 
4385                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
4386 
4387                                 value = opline->op1.zv;
4388                                 ALLOC_ZVAL(copy);
4389                                 INIT_PZVAL_COPY(copy, value);
4390 
4391                                 /* Temporary variables don't need ctor copying */
4392                                 if (!0) {
4393                                         zval_copy_ctor(copy);
4394                                 }
4395 
4396                                 generator->value = copy;
4397                         } else {
4398                                 zval **value_ptr = NULL;
4399 
4400                                 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
4401                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
4402                                 }
4403 
4404                                 /* If a function call result is yielded and the function did
4405                                  * not return by reference we throw a notice. */
4406                                 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
4407                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
4408                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
4409                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
4410                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
4411 
4412                                         Z_ADDREF_PP(value_ptr);
4413                                         generator->value = *value_ptr;
4414                                 } else {
4415                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
4416                                         Z_ADDREF_PP(value_ptr);
4417                                         generator->value = *value_ptr;
4418                                 }
4419 
4420                         }
4421                 } else {
4422                         zval *value = opline->op1.zv;
4423 
4424                         /* Consts, temporary variables and references need copying */
4425                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
4426                                 || PZVAL_IS_REF(value)
4427                         ) {
4428                                 zval *copy;
4429 
4430                                 ALLOC_ZVAL(copy);
4431                                 INIT_PZVAL_COPY(copy, value);
4432 
4433                                 /* Temporary variables don't need ctor copying */
4434                                 if (!0) {
4435                                         zval_copy_ctor(copy);
4436                                 }
4437 
4438                                 generator->value = copy;
4439 
4440                         } else {
4441                                 if (IS_CONST == IS_CV) {
4442                                         Z_ADDREF_P(value);
4443                                 }
4444                                 generator->value = value;
4445                         }
4446                 }
4447         } else {
4448                 /* If no value was specified yield null */
4449                 Z_ADDREF(EG(uninitialized_zval));
4450                 generator->value = &EG(uninitialized_zval);
4451         }
4452 
4453         /* Set the new yielded key */
4454         if (IS_CONST != IS_UNUSED) {
4455 
4456                 zval *key = opline->op2.zv;
4457 
4458                 /* Consts, temporary variables and references need copying */
4459                 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
4460                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
4461                 ) {
4462                         zval *copy;
4463 
4464                         ALLOC_ZVAL(copy);
4465                         INIT_PZVAL_COPY(copy, key);
4466 
4467                         /* Temporary variables don't need ctor copying */
4468                         if (!0) {
4469                                 zval_copy_ctor(copy);
4470                         }
4471 
4472                         generator->key = copy;
4473                 } else {
4474                         Z_ADDREF_P(key);
4475                         generator->key = key;
4476                 }
4477 
4478                 if (Z_TYPE_P(generator->key) == IS_LONG
4479                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
4480                 ) {
4481                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
4482                 }
4483 
4484         } else {
4485                 /* If no key was specified we use auto-increment keys */
4486                 generator->largest_used_integer_key++;
4487 
4488                 ALLOC_INIT_ZVAL(generator->key);
4489                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
4490         }
4491 
4492         if (RETURN_VALUE_USED(opline)) {
4493                 /* If the return value of yield is used set the send
4494                  * target and initialize it to NULL */
4495                 generator->send_target = &EX_T(opline->result.var).var.ptr;
4496                 Z_ADDREF(EG(uninitialized_zval));
4497                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
4498         } else {
4499                 generator->send_target = NULL;
4500         }
4501 
4502         /* We increment to the next op, so we are at the correct position when the
4503          * generator is resumed. */
4504         ZEND_VM_INC_OPCODE();
4505 
4506         /* The GOTO VM uses a local opline variable. We need to set the opline
4507          * variable in execute_data so we don't resume at an old position. */
4508         SAVE_OPLINE();
4509 
4510         ZEND_VM_RETURN();
4511 }
4512 
4513 static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4514 {
4515         USE_OPLINE
4516 
4517 
4518         SAVE_OPLINE();
4519         pow_function(&EX_T(opline->result.var).tmp_var,
4520                 opline->op1.zv,
4521                 opline->op2.zv TSRMLS_CC);
4522 
4523 
4524         CHECK_EXCEPTION();
4525         ZEND_VM_NEXT_OPCODE();
4526 }
4527 
4528 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4529 {
4530         USE_OPLINE
4531         zend_free_op free_op2;
4532 
4533         SAVE_OPLINE();
4534         fast_add_function(&EX_T(opline->result.var).tmp_var,
4535                 opline->op1.zv,
4536                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4537 
4538         zval_dtor(free_op2.var);
4539         CHECK_EXCEPTION();
4540         ZEND_VM_NEXT_OPCODE();
4541 }
4542 
4543 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4544 {
4545         USE_OPLINE
4546         zend_free_op free_op2;
4547 
4548         SAVE_OPLINE();
4549         fast_sub_function(&EX_T(opline->result.var).tmp_var,
4550                 opline->op1.zv,
4551                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4552 
4553         zval_dtor(free_op2.var);
4554         CHECK_EXCEPTION();
4555         ZEND_VM_NEXT_OPCODE();
4556 }
4557 
4558 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4559 {
4560         USE_OPLINE
4561         zend_free_op free_op2;
4562 
4563         SAVE_OPLINE();
4564         fast_mul_function(&EX_T(opline->result.var).tmp_var,
4565                 opline->op1.zv,
4566                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4567 
4568         zval_dtor(free_op2.var);
4569         CHECK_EXCEPTION();
4570         ZEND_VM_NEXT_OPCODE();
4571 }
4572 
4573 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4574 {
4575         USE_OPLINE
4576         zend_free_op free_op2;
4577 
4578         SAVE_OPLINE();
4579         fast_div_function(&EX_T(opline->result.var).tmp_var,
4580                 opline->op1.zv,
4581                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4582 
4583         zval_dtor(free_op2.var);
4584         CHECK_EXCEPTION();
4585         ZEND_VM_NEXT_OPCODE();
4586 }
4587 
4588 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4589 {
4590         USE_OPLINE
4591         zend_free_op free_op2;
4592 
4593         SAVE_OPLINE();
4594         fast_mod_function(&EX_T(opline->result.var).tmp_var,
4595                 opline->op1.zv,
4596                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4597 
4598         zval_dtor(free_op2.var);
4599         CHECK_EXCEPTION();
4600         ZEND_VM_NEXT_OPCODE();
4601 }
4602 
4603 static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4604 {
4605         USE_OPLINE
4606         zend_free_op free_op2;
4607 
4608         SAVE_OPLINE();
4609         shift_left_function(&EX_T(opline->result.var).tmp_var,
4610                 opline->op1.zv,
4611                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4612 
4613         zval_dtor(free_op2.var);
4614         CHECK_EXCEPTION();
4615         ZEND_VM_NEXT_OPCODE();
4616 }
4617 
4618 static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4619 {
4620         USE_OPLINE
4621         zend_free_op free_op2;
4622 
4623         SAVE_OPLINE();
4624         shift_right_function(&EX_T(opline->result.var).tmp_var,
4625                 opline->op1.zv,
4626                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4627 
4628         zval_dtor(free_op2.var);
4629         CHECK_EXCEPTION();
4630         ZEND_VM_NEXT_OPCODE();
4631 }
4632 
4633 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4634 {
4635         USE_OPLINE
4636         zend_free_op free_op2;
4637 
4638         SAVE_OPLINE();
4639         concat_function(&EX_T(opline->result.var).tmp_var,
4640                 opline->op1.zv,
4641                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4642 
4643         zval_dtor(free_op2.var);
4644         CHECK_EXCEPTION();
4645         ZEND_VM_NEXT_OPCODE();
4646 }
4647 
4648 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4649 {
4650         USE_OPLINE
4651         zend_free_op free_op2;
4652 
4653         SAVE_OPLINE();
4654         is_identical_function(&EX_T(opline->result.var).tmp_var,
4655                 opline->op1.zv,
4656                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4657 
4658         zval_dtor(free_op2.var);
4659         CHECK_EXCEPTION();
4660         ZEND_VM_NEXT_OPCODE();
4661 }
4662 
4663 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4664 {
4665         USE_OPLINE
4666         zend_free_op free_op2;
4667         zval *result = &EX_T(opline->result.var).tmp_var;
4668 
4669         SAVE_OPLINE();
4670         is_identical_function(result,
4671                 opline->op1.zv,
4672                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4673         Z_LVAL_P(result) = !Z_LVAL_P(result);
4674 
4675         zval_dtor(free_op2.var);
4676         CHECK_EXCEPTION();
4677         ZEND_VM_NEXT_OPCODE();
4678 }
4679 
4680 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4681 {
4682         USE_OPLINE
4683         zend_free_op free_op2;
4684         zval *result = &EX_T(opline->result.var).tmp_var;
4685 
4686         SAVE_OPLINE();
4687         ZVAL_BOOL(result, fast_equal_function(result,
4688                 opline->op1.zv,
4689                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
4690 
4691         zval_dtor(free_op2.var);
4692         CHECK_EXCEPTION();
4693         ZEND_VM_NEXT_OPCODE();
4694 }
4695 
4696 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4697 {
4698         USE_OPLINE
4699         zend_free_op free_op2;
4700         zval *result = &EX_T(opline->result.var).tmp_var;
4701 
4702         SAVE_OPLINE();
4703         ZVAL_BOOL(result, fast_not_equal_function(result,
4704                 opline->op1.zv,
4705                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
4706 
4707         zval_dtor(free_op2.var);
4708         CHECK_EXCEPTION();
4709         ZEND_VM_NEXT_OPCODE();
4710 }
4711 
4712 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4713 {
4714         USE_OPLINE
4715         zend_free_op free_op2;
4716         zval *result = &EX_T(opline->result.var).tmp_var;
4717 
4718         SAVE_OPLINE();
4719         ZVAL_BOOL(result, fast_is_smaller_function(result,
4720                 opline->op1.zv,
4721                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
4722 
4723         zval_dtor(free_op2.var);
4724         CHECK_EXCEPTION();
4725         ZEND_VM_NEXT_OPCODE();
4726 }
4727 
4728 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4729 {
4730         USE_OPLINE
4731         zend_free_op free_op2;
4732         zval *result = &EX_T(opline->result.var).tmp_var;
4733 
4734         SAVE_OPLINE();
4735         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
4736                 opline->op1.zv,
4737                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
4738 
4739         zval_dtor(free_op2.var);
4740         CHECK_EXCEPTION();
4741         ZEND_VM_NEXT_OPCODE();
4742 }
4743 
4744 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4745 {
4746         USE_OPLINE
4747         zend_free_op free_op2;
4748 
4749         SAVE_OPLINE();
4750         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
4751                 opline->op1.zv,
4752                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4753 
4754         zval_dtor(free_op2.var);
4755         CHECK_EXCEPTION();
4756         ZEND_VM_NEXT_OPCODE();
4757 }
4758 
4759 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4760 {
4761         USE_OPLINE
4762         zend_free_op free_op2;
4763 
4764         SAVE_OPLINE();
4765         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
4766                 opline->op1.zv,
4767                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4768 
4769         zval_dtor(free_op2.var);
4770         CHECK_EXCEPTION();
4771         ZEND_VM_NEXT_OPCODE();
4772 }
4773 
4774 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4775 {
4776         USE_OPLINE
4777         zend_free_op free_op2;
4778 
4779         SAVE_OPLINE();
4780         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
4781                 opline->op1.zv,
4782                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4783 
4784         zval_dtor(free_op2.var);
4785         CHECK_EXCEPTION();
4786         ZEND_VM_NEXT_OPCODE();
4787 }
4788 
4789 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4790 {
4791         USE_OPLINE
4792         zend_free_op free_op2;
4793 
4794         SAVE_OPLINE();
4795         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
4796                 opline->op1.zv,
4797                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4798 
4799         zval_dtor(free_op2.var);
4800         CHECK_EXCEPTION();
4801         ZEND_VM_NEXT_OPCODE();
4802 }
4803 
4804 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4805 {
4806         USE_OPLINE
4807         zend_free_op free_op2;
4808         zval *container;
4809 
4810         SAVE_OPLINE();
4811         container = opline->op1.zv;
4812         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
4813         zval_dtor(free_op2.var);
4814         if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
4815 
4816         }
4817         CHECK_EXCEPTION();
4818         ZEND_VM_NEXT_OPCODE();
4819 }
4820 
4821 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4822 {
4823         USE_OPLINE
4824         zval *function_name;
4825         zend_class_entry *ce;
4826         call_slot *call = EX(call_slots) + opline->result.num;
4827 
4828         SAVE_OPLINE();
4829 
4830         if (IS_CONST == IS_CONST) {
4831                 /* no function found. try a static method in class */
4832                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
4833                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
4834                 } else {
4835                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
4836                         if (UNEXPECTED(EG(exception) != NULL)) {
4837                                 HANDLE_EXCEPTION();
4838                         }
4839                         if (UNEXPECTED(ce == NULL)) {
4840                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
4841                         }
4842                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
4843                 }
4844                 call->called_scope = ce;
4845         } else {
4846                 ce = EX_T(opline->op1.var).class_entry;
4847 
4848                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
4849                         call->called_scope = EG(called_scope);
4850                 } else {
4851                         call->called_scope = ce;
4852                 }
4853         }
4854 
4855         if (IS_CONST == IS_CONST &&
4856             IS_TMP_VAR == IS_CONST &&
4857             CACHED_PTR(opline->op2.literal->cache_slot)) {
4858                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
4859         } else if (IS_CONST != IS_CONST &&
4860                    IS_TMP_VAR == IS_CONST &&
4861                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
4862                 /* do nothing */
4863         } else if (IS_TMP_VAR != IS_UNUSED) {
4864                 char *function_name_strval = NULL;
4865                 int function_name_strlen = 0;
4866                 zend_free_op free_op2;
4867 
4868                 if (IS_TMP_VAR == IS_CONST) {
4869                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
4870                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
4871                 } else {
4872                         function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
4873 
4874                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
4875                                 if (UNEXPECTED(EG(exception) != NULL)) {
4876                                         HANDLE_EXCEPTION();
4877                                 }
4878                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
4879                         } else {
4880                                 function_name_strval = Z_STRVAL_P(function_name);
4881                                 function_name_strlen = Z_STRLEN_P(function_name);
4882                         }
4883                 }
4884 
4885                 if (function_name_strval) {
4886                         if (ce->get_static_method) {
4887                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
4888                         } else {
4889                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
4890                         }
4891                         if (UNEXPECTED(call->fbc == NULL)) {
4892                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
4893                         }
4894                         if (IS_TMP_VAR == IS_CONST &&
4895                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
4896                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
4897                                 if (IS_CONST == IS_CONST) {
4898                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
4899                                 } else {
4900                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
4901                                 }
4902                         }
4903                 }
4904                 if (IS_TMP_VAR != IS_CONST) {
4905                         zval_dtor(free_op2.var);
4906                 }
4907         } else {
4908                 if (UNEXPECTED(ce->constructor == NULL)) {
4909                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
4910                 }
4911                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
4912                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
4913                 }
4914                 call->fbc = ce->constructor;
4915         }
4916 
4917         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
4918                 call->object = NULL;
4919         } else {
4920                 if (EG(This) &&
4921                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
4922                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
4923                     /* We are calling method of the other (incompatible) class,
4924                        but passing $this. This is done for compatibility with php-4. */
4925                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
4926                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
4927                         } else {
4928                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
4929                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
4930                         }
4931                 }
4932                 if ((call->object = EG(This))) {
4933                         Z_ADDREF_P(call->object);
4934                         call->called_scope = Z_OBJCE_P(call->object);
4935                 }
4936         }
4937 
4938         call->num_additional_args = 0;
4939         call->is_ctor_call = 0;
4940         EX(call) = call;
4941 
4942         CHECK_EXCEPTION();
4943         ZEND_VM_NEXT_OPCODE();
4944 }
4945 
4946 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4947 {
4948         USE_OPLINE
4949         zend_free_op free_op2;
4950 
4951         SAVE_OPLINE();
4952         is_equal_function(&EX_T(opline->result.var).tmp_var,
4953                                  opline->op1.zv,
4954                                  _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
4955 
4956         zval_dtor(free_op2.var);
4957         CHECK_EXCEPTION();
4958         ZEND_VM_NEXT_OPCODE();
4959 }
4960 
4961 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4962 {
4963         USE_OPLINE
4964 
4965         zval *expr_ptr;
4966 
4967         SAVE_OPLINE();
4968         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
4969                 zval **expr_ptr_ptr = NULL;
4970 
4971                 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
4972                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
4973                 }
4974                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
4975                 expr_ptr = *expr_ptr_ptr;
4976                 Z_ADDREF_P(expr_ptr);
4977         } else {
4978                 expr_ptr=opline->op1.zv;
4979                 if (0) { /* temporary variable */
4980                         zval *new_expr;
4981 
4982                         ALLOC_ZVAL(new_expr);
4983                         INIT_PZVAL_COPY(new_expr, expr_ptr);
4984                         expr_ptr = new_expr;
4985                 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
4986                         zval *new_expr;
4987 
4988                         ALLOC_ZVAL(new_expr);
4989                         INIT_PZVAL_COPY(new_expr, expr_ptr);
4990                         expr_ptr = new_expr;
4991                         zendi_zval_copy_ctor(*expr_ptr);
4992 
4993                 } else if (IS_CONST == IS_CV) {
4994                         Z_ADDREF_P(expr_ptr);
4995                 }
4996         }
4997 
4998         if (IS_TMP_VAR != IS_UNUSED) {
4999                 zend_free_op free_op2;
5000                 zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
5001                 ulong hval;
5002 
5003                 switch (Z_TYPE_P(offset)) {
5004                         case IS_DOUBLE:
5005                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
5006                                 goto num_index;
5007                         case IS_LONG:
5008                         case IS_BOOL:
5009                                 hval = Z_LVAL_P(offset);
5010 num_index:
5011                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
5012                                 break;
5013                         case IS_STRING:
5014                                 if (IS_TMP_VAR == IS_CONST) {
5015                                         hval = Z_HASH_P(offset);
5016                                 } else {
5017                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
5018                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
5019                                 }
5020                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
5021                                 break;
5022                         case IS_NULL:
5023                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
5024                                 break;
5025                         default:
5026                                 zend_error(E_WARNING, "Illegal offset type");
5027                                 zval_ptr_dtor(&expr_ptr);
5028                                 /* do nothing */
5029                                 break;
5030                 }
5031                 zval_dtor(free_op2.var);
5032         } else {
5033                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
5034         }
5035         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
5036 
5037         }
5038         CHECK_EXCEPTION();
5039         ZEND_VM_NEXT_OPCODE();
5040 }
5041 
5042 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5043 {
5044         USE_OPLINE
5045 
5046         array_init(&EX_T(opline->result.var).tmp_var);
5047         if (IS_CONST == IS_UNUSED) {
5048                 ZEND_VM_NEXT_OPCODE();
5049 #if 0 || IS_CONST != IS_UNUSED
5050         } else {
5051                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5052 #endif
5053         }
5054 }
5055 
5056 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5057 {
5058         USE_OPLINE
5059 
5060         /* The generator object is stored in return_value_ptr_ptr */
5061         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
5062 
5063         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
5064                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
5065         }
5066 
5067         /* Destroy the previously yielded value */
5068         if (generator->value) {
5069                 zval_ptr_dtor(&generator->value);
5070         }
5071 
5072         /* Destroy the previously yielded key */
5073         if (generator->key) {
5074                 zval_ptr_dtor(&generator->key);
5075         }
5076 
5077         /* Set the new yielded value */
5078         if (IS_CONST != IS_UNUSED) {
5079 
5080 
5081                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
5082                         /* Constants and temporary variables aren't yieldable by reference,
5083                          * but we still allow them with a notice. */
5084                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
5085                                 zval *value, *copy;
5086 
5087                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
5088 
5089                                 value = opline->op1.zv;
5090                                 ALLOC_ZVAL(copy);
5091                                 INIT_PZVAL_COPY(copy, value);
5092 
5093                                 /* Temporary variables don't need ctor copying */
5094                                 if (!0) {
5095                                         zval_copy_ctor(copy);
5096                                 }
5097 
5098                                 generator->value = copy;
5099                         } else {
5100                                 zval **value_ptr = NULL;
5101 
5102                                 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
5103                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
5104                                 }
5105 
5106                                 /* If a function call result is yielded and the function did
5107                                  * not return by reference we throw a notice. */
5108                                 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
5109                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
5110                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
5111                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
5112                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
5113 
5114                                         Z_ADDREF_PP(value_ptr);
5115                                         generator->value = *value_ptr;
5116                                 } else {
5117                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
5118                                         Z_ADDREF_PP(value_ptr);
5119                                         generator->value = *value_ptr;
5120                                 }
5121 
5122                         }
5123                 } else {
5124                         zval *value = opline->op1.zv;
5125 
5126                         /* Consts, temporary variables and references need copying */
5127                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
5128                                 || PZVAL_IS_REF(value)
5129                         ) {
5130                                 zval *copy;
5131 
5132                                 ALLOC_ZVAL(copy);
5133                                 INIT_PZVAL_COPY(copy, value);
5134 
5135                                 /* Temporary variables don't need ctor copying */
5136                                 if (!0) {
5137                                         zval_copy_ctor(copy);
5138                                 }
5139 
5140                                 generator->value = copy;
5141 
5142                         } else {
5143                                 if (IS_CONST == IS_CV) {
5144                                         Z_ADDREF_P(value);
5145                                 }
5146                                 generator->value = value;
5147                         }
5148                 }
5149         } else {
5150                 /* If no value was specified yield null */
5151                 Z_ADDREF(EG(uninitialized_zval));
5152                 generator->value = &EG(uninitialized_zval);
5153         }
5154 
5155         /* Set the new yielded key */
5156         if (IS_TMP_VAR != IS_UNUSED) {
5157                 zend_free_op free_op2;
5158                 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
5159 
5160                 /* Consts, temporary variables and references need copying */
5161                 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
5162                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
5163                 ) {
5164                         zval *copy;
5165 
5166                         ALLOC_ZVAL(copy);
5167                         INIT_PZVAL_COPY(copy, key);
5168 
5169                         /* Temporary variables don't need ctor copying */
5170                         if (!1) {
5171                                 zval_copy_ctor(copy);
5172                         }
5173 
5174                         generator->key = copy;
5175                 } else {
5176                         Z_ADDREF_P(key);
5177                         generator->key = key;
5178                 }
5179 
5180                 if (Z_TYPE_P(generator->key) == IS_LONG
5181                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
5182                 ) {
5183                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
5184                 }
5185 
5186         } else {
5187                 /* If no key was specified we use auto-increment keys */
5188                 generator->largest_used_integer_key++;
5189 
5190                 ALLOC_INIT_ZVAL(generator->key);
5191                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
5192         }
5193 
5194         if (RETURN_VALUE_USED(opline)) {
5195                 /* If the return value of yield is used set the send
5196                  * target and initialize it to NULL */
5197                 generator->send_target = &EX_T(opline->result.var).var.ptr;
5198                 Z_ADDREF(EG(uninitialized_zval));
5199                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
5200         } else {
5201                 generator->send_target = NULL;
5202         }
5203 
5204         /* We increment to the next op, so we are at the correct position when the
5205          * generator is resumed. */
5206         ZEND_VM_INC_OPCODE();
5207 
5208         /* The GOTO VM uses a local opline variable. We need to set the opline
5209          * variable in execute_data so we don't resume at an old position. */
5210         SAVE_OPLINE();
5211 
5212         ZEND_VM_RETURN();
5213 }
5214 
5215 static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5216 {
5217         USE_OPLINE
5218         zend_free_op free_op2;
5219 
5220         SAVE_OPLINE();
5221         pow_function(&EX_T(opline->result.var).tmp_var,
5222                 opline->op1.zv,
5223                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5224 
5225         zval_dtor(free_op2.var);
5226         CHECK_EXCEPTION();
5227         ZEND_VM_NEXT_OPCODE();
5228 }
5229 
5230 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5231 {
5232         USE_OPLINE
5233         zend_free_op free_op2;
5234 
5235         SAVE_OPLINE();
5236         fast_add_function(&EX_T(opline->result.var).tmp_var,
5237                 opline->op1.zv,
5238                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5239 
5240         zval_ptr_dtor_nogc(&free_op2.var);
5241         CHECK_EXCEPTION();
5242         ZEND_VM_NEXT_OPCODE();
5243 }
5244 
5245 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5246 {
5247         USE_OPLINE
5248         zend_free_op free_op2;
5249 
5250         SAVE_OPLINE();
5251         fast_sub_function(&EX_T(opline->result.var).tmp_var,
5252                 opline->op1.zv,
5253                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5254 
5255         zval_ptr_dtor_nogc(&free_op2.var);
5256         CHECK_EXCEPTION();
5257         ZEND_VM_NEXT_OPCODE();
5258 }
5259 
5260 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5261 {
5262         USE_OPLINE
5263         zend_free_op free_op2;
5264 
5265         SAVE_OPLINE();
5266         fast_mul_function(&EX_T(opline->result.var).tmp_var,
5267                 opline->op1.zv,
5268                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5269 
5270         zval_ptr_dtor_nogc(&free_op2.var);
5271         CHECK_EXCEPTION();
5272         ZEND_VM_NEXT_OPCODE();
5273 }
5274 
5275 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5276 {
5277         USE_OPLINE
5278         zend_free_op free_op2;
5279 
5280         SAVE_OPLINE();
5281         fast_div_function(&EX_T(opline->result.var).tmp_var,
5282                 opline->op1.zv,
5283                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5284 
5285         zval_ptr_dtor_nogc(&free_op2.var);
5286         CHECK_EXCEPTION();
5287         ZEND_VM_NEXT_OPCODE();
5288 }
5289 
5290 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5291 {
5292         USE_OPLINE
5293         zend_free_op free_op2;
5294 
5295         SAVE_OPLINE();
5296         fast_mod_function(&EX_T(opline->result.var).tmp_var,
5297                 opline->op1.zv,
5298                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5299 
5300         zval_ptr_dtor_nogc(&free_op2.var);
5301         CHECK_EXCEPTION();
5302         ZEND_VM_NEXT_OPCODE();
5303 }
5304 
5305 static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5306 {
5307         USE_OPLINE
5308         zend_free_op free_op2;
5309 
5310         SAVE_OPLINE();
5311         shift_left_function(&EX_T(opline->result.var).tmp_var,
5312                 opline->op1.zv,
5313                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5314 
5315         zval_ptr_dtor_nogc(&free_op2.var);
5316         CHECK_EXCEPTION();
5317         ZEND_VM_NEXT_OPCODE();
5318 }
5319 
5320 static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5321 {
5322         USE_OPLINE
5323         zend_free_op free_op2;
5324 
5325         SAVE_OPLINE();
5326         shift_right_function(&EX_T(opline->result.var).tmp_var,
5327                 opline->op1.zv,
5328                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5329 
5330         zval_ptr_dtor_nogc(&free_op2.var);
5331         CHECK_EXCEPTION();
5332         ZEND_VM_NEXT_OPCODE();
5333 }
5334 
5335 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5336 {
5337         USE_OPLINE
5338         zend_free_op free_op2;
5339 
5340         SAVE_OPLINE();
5341         concat_function(&EX_T(opline->result.var).tmp_var,
5342                 opline->op1.zv,
5343                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5344 
5345         zval_ptr_dtor_nogc(&free_op2.var);
5346         CHECK_EXCEPTION();
5347         ZEND_VM_NEXT_OPCODE();
5348 }
5349 
5350 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5351 {
5352         USE_OPLINE
5353         zend_free_op free_op2;
5354 
5355         SAVE_OPLINE();
5356         is_identical_function(&EX_T(opline->result.var).tmp_var,
5357                 opline->op1.zv,
5358                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5359 
5360         zval_ptr_dtor_nogc(&free_op2.var);
5361         CHECK_EXCEPTION();
5362         ZEND_VM_NEXT_OPCODE();
5363 }
5364 
5365 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5366 {
5367         USE_OPLINE
5368         zend_free_op free_op2;
5369         zval *result = &EX_T(opline->result.var).tmp_var;
5370 
5371         SAVE_OPLINE();
5372         is_identical_function(result,
5373                 opline->op1.zv,
5374                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5375         Z_LVAL_P(result) = !Z_LVAL_P(result);
5376 
5377         zval_ptr_dtor_nogc(&free_op2.var);
5378         CHECK_EXCEPTION();
5379         ZEND_VM_NEXT_OPCODE();
5380 }
5381 
5382 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5383 {
5384         USE_OPLINE
5385         zend_free_op free_op2;
5386         zval *result = &EX_T(opline->result.var).tmp_var;
5387 
5388         SAVE_OPLINE();
5389         ZVAL_BOOL(result, fast_equal_function(result,
5390                 opline->op1.zv,
5391                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
5392 
5393         zval_ptr_dtor_nogc(&free_op2.var);
5394         CHECK_EXCEPTION();
5395         ZEND_VM_NEXT_OPCODE();
5396 }
5397 
5398 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5399 {
5400         USE_OPLINE
5401         zend_free_op free_op2;
5402         zval *result = &EX_T(opline->result.var).tmp_var;
5403 
5404         SAVE_OPLINE();
5405         ZVAL_BOOL(result, fast_not_equal_function(result,
5406                 opline->op1.zv,
5407                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
5408 
5409         zval_ptr_dtor_nogc(&free_op2.var);
5410         CHECK_EXCEPTION();
5411         ZEND_VM_NEXT_OPCODE();
5412 }
5413 
5414 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5415 {
5416         USE_OPLINE
5417         zend_free_op free_op2;
5418         zval *result = &EX_T(opline->result.var).tmp_var;
5419 
5420         SAVE_OPLINE();
5421         ZVAL_BOOL(result, fast_is_smaller_function(result,
5422                 opline->op1.zv,
5423                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
5424 
5425         zval_ptr_dtor_nogc(&free_op2.var);
5426         CHECK_EXCEPTION();
5427         ZEND_VM_NEXT_OPCODE();
5428 }
5429 
5430 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5431 {
5432         USE_OPLINE
5433         zend_free_op free_op2;
5434         zval *result = &EX_T(opline->result.var).tmp_var;
5435 
5436         SAVE_OPLINE();
5437         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
5438                 opline->op1.zv,
5439                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
5440 
5441         zval_ptr_dtor_nogc(&free_op2.var);
5442         CHECK_EXCEPTION();
5443         ZEND_VM_NEXT_OPCODE();
5444 }
5445 
5446 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5447 {
5448         USE_OPLINE
5449         zend_free_op free_op2;
5450 
5451         SAVE_OPLINE();
5452         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
5453                 opline->op1.zv,
5454                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5455 
5456         zval_ptr_dtor_nogc(&free_op2.var);
5457         CHECK_EXCEPTION();
5458         ZEND_VM_NEXT_OPCODE();
5459 }
5460 
5461 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5462 {
5463         USE_OPLINE
5464         zend_free_op free_op2;
5465 
5466         SAVE_OPLINE();
5467         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
5468                 opline->op1.zv,
5469                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5470 
5471         zval_ptr_dtor_nogc(&free_op2.var);
5472         CHECK_EXCEPTION();
5473         ZEND_VM_NEXT_OPCODE();
5474 }
5475 
5476 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5477 {
5478         USE_OPLINE
5479         zend_free_op free_op2;
5480 
5481         SAVE_OPLINE();
5482         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
5483                 opline->op1.zv,
5484                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5485 
5486         zval_ptr_dtor_nogc(&free_op2.var);
5487         CHECK_EXCEPTION();
5488         ZEND_VM_NEXT_OPCODE();
5489 }
5490 
5491 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5492 {
5493         USE_OPLINE
5494         zend_free_op free_op2;
5495 
5496         SAVE_OPLINE();
5497         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
5498                 opline->op1.zv,
5499                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5500 
5501         zval_ptr_dtor_nogc(&free_op2.var);
5502         CHECK_EXCEPTION();
5503         ZEND_VM_NEXT_OPCODE();
5504 }
5505 
5506 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
5507 {
5508         USE_OPLINE
5509         zend_free_op free_op1;
5510         zval *varname;
5511         zval **retval;
5512         zval tmp_varname;
5513         HashTable *target_symbol_table;
5514         ulong hash_value;
5515 
5516         SAVE_OPLINE();
5517         varname = opline->op1.zv;
5518 
5519         if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
5520                 ZVAL_COPY_VALUE(&tmp_varname, varname);
5521                 zval_copy_ctor(&tmp_varname);
5522                 Z_SET_REFCOUNT(tmp_varname, 1);
5523                 Z_UNSET_ISREF(tmp_varname);
5524                 convert_to_string(&tmp_varname);
5525                 varname = &tmp_varname;
5526         }
5527 
5528         if (IS_VAR != IS_UNUSED) {
5529                 zend_class_entry *ce;
5530 
5531                 if (IS_VAR == IS_CONST) {
5532                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
5533                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
5534                         } else {
5535                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
5536                                 if (UNEXPECTED(ce == NULL)) {
5537                                         if (IS_CONST != IS_CONST && varname == &tmp_varname) {
5538                                                 zval_dtor(&tmp_varname);
5539                                         }
5540 
5541                                         CHECK_EXCEPTION();
5542                                         ZEND_VM_NEXT_OPCODE();
5543                                 }
5544                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
5545                         }
5546                 } else {
5547                         ce = EX_T(opline->op2.var).class_entry;
5548                 }
5549                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
5550 
5551         } else {
5552                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
5553 /*
5554                 if (!target_symbol_table) {
5555                         CHECK_EXCEPTION();
5556                         ZEND_VM_NEXT_OPCODE();
5557                 }
5558 */
5559                 if (IS_CONST == IS_CONST) {
5560                         hash_value = Z_HASH_P(varname);
5561                 } else {
5562                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
5563                 }
5564 
5565                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
5566                         switch (type) {
5567                                 case BP_VAR_R:
5568                                 case BP_VAR_UNSET:
5569                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
5570                                         /* break missing intentionally */
5571                                 case BP_VAR_IS:
5572                                         retval = &EG(uninitialized_zval_ptr);
5573                                         break;
5574                                 case BP_VAR_RW:
5575                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
5576                                         /* break missing intentionally */
5577                                 case BP_VAR_W:
5578                                         Z_ADDREF_P(&EG(uninitialized_zval));
5579                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
5580                                         break;
5581                                 EMPTY_SWITCH_DEFAULT_CASE()
5582                         }
5583                 }
5584                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
5585                         case ZEND_FETCH_GLOBAL:
5586                                 if (IS_CONST != IS_TMP_VAR) {
5587 
5588                                 }
5589                                 break;
5590                         case ZEND_FETCH_LOCAL:
5591 
5592                                 break;
5593                         case ZEND_FETCH_STATIC:
5594                                 zval_update_constant(retval, 1 TSRMLS_CC);
5595                                 break;
5596                         case ZEND_FETCH_GLOBAL_LOCK:
5597                                 if (IS_CONST == IS_VAR && !free_op1.var) {
5598                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
5599                                 }
5600                                 break;
5601                 }
5602         }
5603 
5604 
5605         if (IS_CONST != IS_CONST && varname == &tmp_varname) {
5606                 zval_dtor(&tmp_varname);
5607         }
5608         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
5609                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
5610         }
5611         PZVAL_LOCK(*retval);
5612         switch (type) {
5613                 case BP_VAR_R:
5614                 case BP_VAR_IS:
5615                         EX_T(opline->result.var).var.ptr = *retval;
5616                         break;
5617                 case BP_VAR_UNSET: {
5618                         zend_free_op free_res;
5619 
5620                         PZVAL_UNLOCK(*retval, &free_res);
5621                         if (retval != &EG(uninitialized_zval_ptr)) {
5622                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
5623                         }
5624                         PZVAL_LOCK(*retval);
5625                         FREE_OP_VAR_PTR(free_res);
5626                 }
5627                 /* break missing intentionally */
5628                 default:
5629                         EX_T(opline->result.var).var.ptr_ptr = retval;
5630                         break;
5631         }
5632         CHECK_EXCEPTION();
5633         ZEND_VM_NEXT_OPCODE();
5634 }
5635 
5636 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5637 {
5638         return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5639 }
5640 
5641 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5642 {
5643         return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5644 }
5645 
5646 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5647 {
5648         return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5649 }
5650 
5651 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5652 {
5653         USE_OPLINE
5654 
5655         return zend_fetch_var_address_helper_SPEC_CONST_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5656 }
5657 
5658 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5659 {
5660         return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5661 }
5662 
5663 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5664 {
5665         return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5666 }
5667 
5668 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5669 {
5670         USE_OPLINE
5671         zend_free_op free_op2;
5672         zval *container;
5673 
5674         SAVE_OPLINE();
5675         container = opline->op1.zv;
5676         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
5677         zval_ptr_dtor_nogc(&free_op2.var);
5678         if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
5679 
5680         }
5681         CHECK_EXCEPTION();
5682         ZEND_VM_NEXT_OPCODE();
5683 }
5684 
5685 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5686 {
5687         USE_OPLINE
5688         zval *function_name;
5689         zend_class_entry *ce;
5690         call_slot *call = EX(call_slots) + opline->result.num;
5691 
5692         SAVE_OPLINE();
5693 
5694         if (IS_CONST == IS_CONST) {
5695                 /* no function found. try a static method in class */
5696                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
5697                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
5698                 } else {
5699                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
5700                         if (UNEXPECTED(EG(exception) != NULL)) {
5701                                 HANDLE_EXCEPTION();
5702                         }
5703                         if (UNEXPECTED(ce == NULL)) {
5704                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
5705                         }
5706                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
5707                 }
5708                 call->called_scope = ce;
5709         } else {
5710                 ce = EX_T(opline->op1.var).class_entry;
5711 
5712                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
5713                         call->called_scope = EG(called_scope);
5714                 } else {
5715                         call->called_scope = ce;
5716                 }
5717         }
5718 
5719         if (IS_CONST == IS_CONST &&
5720             IS_VAR == IS_CONST &&
5721             CACHED_PTR(opline->op2.literal->cache_slot)) {
5722                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
5723         } else if (IS_CONST != IS_CONST &&
5724                    IS_VAR == IS_CONST &&
5725                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
5726                 /* do nothing */
5727         } else if (IS_VAR != IS_UNUSED) {
5728                 char *function_name_strval = NULL;
5729                 int function_name_strlen = 0;
5730                 zend_free_op free_op2;
5731 
5732                 if (IS_VAR == IS_CONST) {
5733                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
5734                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
5735                 } else {
5736                         function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
5737 
5738                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
5739                                 if (UNEXPECTED(EG(exception) != NULL)) {
5740                                         HANDLE_EXCEPTION();
5741                                 }
5742                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
5743                         } else {
5744                                 function_name_strval = Z_STRVAL_P(function_name);
5745                                 function_name_strlen = Z_STRLEN_P(function_name);
5746                         }
5747                 }
5748 
5749                 if (function_name_strval) {
5750                         if (ce->get_static_method) {
5751                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
5752                         } else {
5753                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
5754                         }
5755                         if (UNEXPECTED(call->fbc == NULL)) {
5756                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
5757                         }
5758                         if (IS_VAR == IS_CONST &&
5759                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
5760                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
5761                                 if (IS_CONST == IS_CONST) {
5762                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
5763                                 } else {
5764                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
5765                                 }
5766                         }
5767                 }
5768                 if (IS_VAR != IS_CONST) {
5769                         zval_ptr_dtor_nogc(&free_op2.var);
5770                 }
5771         } else {
5772                 if (UNEXPECTED(ce->constructor == NULL)) {
5773                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
5774                 }
5775                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
5776                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
5777                 }
5778                 call->fbc = ce->constructor;
5779         }
5780 
5781         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
5782                 call->object = NULL;
5783         } else {
5784                 if (EG(This) &&
5785                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
5786                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
5787                     /* We are calling method of the other (incompatible) class,
5788                        but passing $this. This is done for compatibility with php-4. */
5789                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
5790                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
5791                         } else {
5792                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
5793                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
5794                         }
5795                 }
5796                 if ((call->object = EG(This))) {
5797                         Z_ADDREF_P(call->object);
5798                         call->called_scope = Z_OBJCE_P(call->object);
5799                 }
5800         }
5801 
5802         call->num_additional_args = 0;
5803         call->is_ctor_call = 0;
5804         EX(call) = call;
5805 
5806         CHECK_EXCEPTION();
5807         ZEND_VM_NEXT_OPCODE();
5808 }
5809 
5810 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5811 {
5812         USE_OPLINE
5813         zend_free_op free_op2;
5814 
5815         SAVE_OPLINE();
5816         is_equal_function(&EX_T(opline->result.var).tmp_var,
5817                                  opline->op1.zv,
5818                                  _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
5819 
5820         zval_ptr_dtor_nogc(&free_op2.var);
5821         CHECK_EXCEPTION();
5822         ZEND_VM_NEXT_OPCODE();
5823 }
5824 
5825 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5826 {
5827         USE_OPLINE
5828 
5829         zval *expr_ptr;
5830 
5831         SAVE_OPLINE();
5832         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
5833                 zval **expr_ptr_ptr = NULL;
5834 
5835                 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
5836                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
5837                 }
5838                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
5839                 expr_ptr = *expr_ptr_ptr;
5840                 Z_ADDREF_P(expr_ptr);
5841         } else {
5842                 expr_ptr=opline->op1.zv;
5843                 if (0) { /* temporary variable */
5844                         zval *new_expr;
5845 
5846                         ALLOC_ZVAL(new_expr);
5847                         INIT_PZVAL_COPY(new_expr, expr_ptr);
5848                         expr_ptr = new_expr;
5849                 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
5850                         zval *new_expr;
5851 
5852                         ALLOC_ZVAL(new_expr);
5853                         INIT_PZVAL_COPY(new_expr, expr_ptr);
5854                         expr_ptr = new_expr;
5855                         zendi_zval_copy_ctor(*expr_ptr);
5856 
5857                 } else if (IS_CONST == IS_CV) {
5858                         Z_ADDREF_P(expr_ptr);
5859                 }
5860         }
5861 
5862         if (IS_VAR != IS_UNUSED) {
5863                 zend_free_op free_op2;
5864                 zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
5865                 ulong hval;
5866 
5867                 switch (Z_TYPE_P(offset)) {
5868                         case IS_DOUBLE:
5869                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
5870                                 goto num_index;
5871                         case IS_LONG:
5872                         case IS_BOOL:
5873                                 hval = Z_LVAL_P(offset);
5874 num_index:
5875                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
5876                                 break;
5877                         case IS_STRING:
5878                                 if (IS_VAR == IS_CONST) {
5879                                         hval = Z_HASH_P(offset);
5880                                 } else {
5881                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
5882                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
5883                                 }
5884                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
5885                                 break;
5886                         case IS_NULL:
5887                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
5888                                 break;
5889                         default:
5890                                 zend_error(E_WARNING, "Illegal offset type");
5891                                 zval_ptr_dtor(&expr_ptr);
5892                                 /* do nothing */
5893                                 break;
5894                 }
5895                 zval_ptr_dtor_nogc(&free_op2.var);
5896         } else {
5897                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
5898         }
5899         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
5900 
5901         }
5902         CHECK_EXCEPTION();
5903         ZEND_VM_NEXT_OPCODE();
5904 }
5905 
5906 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5907 {
5908         USE_OPLINE
5909 
5910         array_init(&EX_T(opline->result.var).tmp_var);
5911         if (IS_CONST == IS_UNUSED) {
5912                 ZEND_VM_NEXT_OPCODE();
5913 #if 0 || IS_CONST != IS_UNUSED
5914         } else {
5915                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
5916 #endif
5917         }
5918 }
5919 
5920 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5921 {
5922         USE_OPLINE
5923         zval tmp, *varname;
5924         HashTable *target_symbol_table;
5925 
5926 
5927         SAVE_OPLINE();
5928         if (IS_CONST == IS_CV &&
5929             IS_VAR == IS_UNUSED &&
5930             (opline->extended_value & ZEND_QUICK_SET)) {
5931                 if (EG(active_symbol_table)) {
5932                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
5933 
5934                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
5935                         EX_CV(opline->op1.var) = NULL;
5936                 } else if (EX_CV(opline->op1.var)) {
5937                         zval_ptr_dtor(EX_CV(opline->op1.var));
5938                         EX_CV(opline->op1.var) = NULL;
5939                 }
5940                 CHECK_EXCEPTION();
5941                 ZEND_VM_NEXT_OPCODE();
5942         }
5943 
5944         varname = opline->op1.zv;
5945 
5946         if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
5947                 ZVAL_COPY_VALUE(&tmp, varname);
5948                 zval_copy_ctor(&tmp);
5949                 convert_to_string(&tmp);
5950                 varname = &tmp;
5951         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5952                 Z_ADDREF_P(varname);
5953         }
5954 
5955         if (IS_VAR != IS_UNUSED) {
5956                 zend_class_entry *ce;
5957 
5958                 if (IS_VAR == IS_CONST) {
5959                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
5960                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
5961                         } else {
5962                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
5963                                 if (UNEXPECTED(EG(exception) != NULL)) {
5964                                         if (IS_CONST != IS_CONST && varname == &tmp) {
5965                                                 zval_dtor(&tmp);
5966                                         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5967                                                 zval_ptr_dtor(&varname);
5968                                         }
5969 
5970                                         HANDLE_EXCEPTION();
5971                                 }
5972                                 if (UNEXPECTED(ce == NULL)) {
5973                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
5974                                 }
5975                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
5976                         }
5977                 } else {
5978                         ce = EX_T(opline->op2.var).class_entry;
5979                 }
5980                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
5981         } else {
5982                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
5983 
5984                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
5985                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
5986         }
5987 
5988         if (IS_CONST != IS_CONST && varname == &tmp) {
5989                 zval_dtor(&tmp);
5990         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5991                 zval_ptr_dtor(&varname);
5992         }
5993 
5994         CHECK_EXCEPTION();
5995         ZEND_VM_NEXT_OPCODE();
5996 }
5997 
5998 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5999 {
6000         USE_OPLINE
6001         zval **value;
6002         zend_bool isset = 1;
6003 
6004         SAVE_OPLINE();
6005         if (IS_CONST == IS_CV &&
6006             IS_VAR == IS_UNUSED &&
6007             (opline->extended_value & ZEND_QUICK_SET)) {
6008                 if (EX_CV(opline->op1.var)) {
6009                         value = EX_CV(opline->op1.var);
6010                 } else if (EG(active_symbol_table)) {
6011                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
6012 
6013                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
6014                                 isset = 0;
6015                         }
6016                 } else {
6017                         isset = 0;
6018                 }
6019         } else {
6020                 HashTable *target_symbol_table;
6021 
6022                 zval tmp, *varname = opline->op1.zv;
6023 
6024                 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
6025                         ZVAL_COPY_VALUE(&tmp, varname);
6026                         zval_copy_ctor(&tmp);
6027                         convert_to_string(&tmp);
6028                         varname = &tmp;
6029                 }
6030 
6031                 if (IS_VAR != IS_UNUSED) {
6032                         zend_class_entry *ce;
6033 
6034                         if (IS_VAR == IS_CONST) {
6035                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
6036                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
6037                                 } else {
6038                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
6039                                         if (UNEXPECTED(ce == NULL)) {
6040                                                 CHECK_EXCEPTION();
6041                                                 ZEND_VM_NEXT_OPCODE();
6042                                         }
6043                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
6044                                 }
6045                         } else {
6046                                 ce = EX_T(opline->op2.var).class_entry;
6047                         }
6048                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
6049                         if (!value) {
6050                                 isset = 0;
6051                         }
6052                 } else {
6053                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
6054                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
6055                                 isset = 0;
6056                         }
6057                 }
6058 
6059                 if (IS_CONST != IS_CONST && varname == &tmp) {
6060                         zval_dtor(&tmp);
6061                 }
6062 
6063         }
6064 
6065         if (opline->extended_value & ZEND_ISSET) {
6066                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
6067                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
6068                 } else {
6069                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
6070                 }
6071         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
6072                 if (!isset || !i_zend_is_true(*value)) {
6073                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
6074                 } else {
6075                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
6076                 }
6077         }
6078 
6079         CHECK_EXCEPTION();
6080         ZEND_VM_NEXT_OPCODE();
6081 }
6082 
6083 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6084 {
6085         USE_OPLINE
6086 
6087         /* The generator object is stored in return_value_ptr_ptr */
6088         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
6089 
6090         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
6091                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
6092         }
6093 
6094         /* Destroy the previously yielded value */
6095         if (generator->value) {
6096                 zval_ptr_dtor(&generator->value);
6097         }
6098 
6099         /* Destroy the previously yielded key */
6100         if (generator->key) {
6101                 zval_ptr_dtor(&generator->key);
6102         }
6103 
6104         /* Set the new yielded value */
6105         if (IS_CONST != IS_UNUSED) {
6106 
6107 
6108                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
6109                         /* Constants and temporary variables aren't yieldable by reference,
6110                          * but we still allow them with a notice. */
6111                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
6112                                 zval *value, *copy;
6113 
6114                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
6115 
6116                                 value = opline->op1.zv;
6117                                 ALLOC_ZVAL(copy);
6118                                 INIT_PZVAL_COPY(copy, value);
6119 
6120                                 /* Temporary variables don't need ctor copying */
6121                                 if (!0) {
6122                                         zval_copy_ctor(copy);
6123                                 }
6124 
6125                                 generator->value = copy;
6126                         } else {
6127                                 zval **value_ptr = NULL;
6128 
6129                                 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
6130                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
6131                                 }
6132 
6133                                 /* If a function call result is yielded and the function did
6134                                  * not return by reference we throw a notice. */
6135                                 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
6136                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
6137                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
6138                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
6139                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
6140 
6141                                         Z_ADDREF_PP(value_ptr);
6142                                         generator->value = *value_ptr;
6143                                 } else {
6144                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
6145                                         Z_ADDREF_PP(value_ptr);
6146                                         generator->value = *value_ptr;
6147                                 }
6148 
6149                         }
6150                 } else {
6151                         zval *value = opline->op1.zv;
6152 
6153                         /* Consts, temporary variables and references need copying */
6154                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
6155                                 || PZVAL_IS_REF(value)
6156                         ) {
6157                                 zval *copy;
6158 
6159                                 ALLOC_ZVAL(copy);
6160                                 INIT_PZVAL_COPY(copy, value);
6161 
6162                                 /* Temporary variables don't need ctor copying */
6163                                 if (!0) {
6164                                         zval_copy_ctor(copy);
6165                                 }
6166 
6167                                 generator->value = copy;
6168 
6169                         } else {
6170                                 if (IS_CONST == IS_CV) {
6171                                         Z_ADDREF_P(value);
6172                                 }
6173                                 generator->value = value;
6174                         }
6175                 }
6176         } else {
6177                 /* If no value was specified yield null */
6178                 Z_ADDREF(EG(uninitialized_zval));
6179                 generator->value = &EG(uninitialized_zval);
6180         }
6181 
6182         /* Set the new yielded key */
6183         if (IS_VAR != IS_UNUSED) {
6184                 zend_free_op free_op2;
6185                 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
6186 
6187                 /* Consts, temporary variables and references need copying */
6188                 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
6189                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
6190                 ) {
6191                         zval *copy;
6192 
6193                         ALLOC_ZVAL(copy);
6194                         INIT_PZVAL_COPY(copy, key);
6195 
6196                         /* Temporary variables don't need ctor copying */
6197                         if (!0) {
6198                                 zval_copy_ctor(copy);
6199                         }
6200 
6201                         generator->key = copy;
6202                 } else {
6203                         Z_ADDREF_P(key);
6204                         generator->key = key;
6205                 }
6206 
6207                 if (Z_TYPE_P(generator->key) == IS_LONG
6208                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
6209                 ) {
6210                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
6211                 }
6212 
6213                 zval_ptr_dtor_nogc(&free_op2.var);
6214         } else {
6215                 /* If no key was specified we use auto-increment keys */
6216                 generator->largest_used_integer_key++;
6217 
6218                 ALLOC_INIT_ZVAL(generator->key);
6219                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
6220         }
6221 
6222         if (RETURN_VALUE_USED(opline)) {
6223                 /* If the return value of yield is used set the send
6224                  * target and initialize it to NULL */
6225                 generator->send_target = &EX_T(opline->result.var).var.ptr;
6226                 Z_ADDREF(EG(uninitialized_zval));
6227                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
6228         } else {
6229                 generator->send_target = NULL;
6230         }
6231 
6232         /* We increment to the next op, so we are at the correct position when the
6233          * generator is resumed. */
6234         ZEND_VM_INC_OPCODE();
6235 
6236         /* The GOTO VM uses a local opline variable. We need to set the opline
6237          * variable in execute_data so we don't resume at an old position. */
6238         SAVE_OPLINE();
6239 
6240         ZEND_VM_RETURN();
6241 }
6242 
6243 static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6244 {
6245         USE_OPLINE
6246         zend_free_op free_op2;
6247 
6248         SAVE_OPLINE();
6249         pow_function(&EX_T(opline->result.var).tmp_var,
6250                 opline->op1.zv,
6251                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
6252 
6253         zval_ptr_dtor_nogc(&free_op2.var);
6254         CHECK_EXCEPTION();
6255         ZEND_VM_NEXT_OPCODE();
6256 }
6257 
6258 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
6259 {
6260         USE_OPLINE
6261         zend_free_op free_op1;
6262         zval *varname;
6263         zval **retval;
6264         zval tmp_varname;
6265         HashTable *target_symbol_table;
6266         ulong hash_value;
6267 
6268         SAVE_OPLINE();
6269         varname = opline->op1.zv;
6270 
6271         if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
6272                 ZVAL_COPY_VALUE(&tmp_varname, varname);
6273                 zval_copy_ctor(&tmp_varname);
6274                 Z_SET_REFCOUNT(tmp_varname, 1);
6275                 Z_UNSET_ISREF(tmp_varname);
6276                 convert_to_string(&tmp_varname);
6277                 varname = &tmp_varname;
6278         }
6279 
6280         if (IS_UNUSED != IS_UNUSED) {
6281                 zend_class_entry *ce;
6282 
6283                 if (IS_UNUSED == IS_CONST) {
6284                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
6285                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
6286                         } else {
6287                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
6288                                 if (UNEXPECTED(ce == NULL)) {
6289                                         if (IS_CONST != IS_CONST && varname == &tmp_varname) {
6290                                                 zval_dtor(&tmp_varname);
6291                                         }
6292 
6293                                         CHECK_EXCEPTION();
6294                                         ZEND_VM_NEXT_OPCODE();
6295                                 }
6296                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
6297                         }
6298                 } else {
6299                         ce = EX_T(opline->op2.var).class_entry;
6300                 }
6301                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
6302 
6303         } else {
6304                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
6305 /*
6306                 if (!target_symbol_table) {
6307                         CHECK_EXCEPTION();
6308                         ZEND_VM_NEXT_OPCODE();
6309                 }
6310 */
6311                 if (IS_CONST == IS_CONST) {
6312                         hash_value = Z_HASH_P(varname);
6313                 } else {
6314                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
6315                 }
6316 
6317                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
6318                         switch (type) {
6319                                 case BP_VAR_R:
6320                                 case BP_VAR_UNSET:
6321                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
6322                                         /* break missing intentionally */
6323                                 case BP_VAR_IS:
6324                                         retval = &EG(uninitialized_zval_ptr);
6325                                         break;
6326                                 case BP_VAR_RW:
6327                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
6328                                         /* break missing intentionally */
6329                                 case BP_VAR_W:
6330                                         Z_ADDREF_P(&EG(uninitialized_zval));
6331                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
6332                                         break;
6333                                 EMPTY_SWITCH_DEFAULT_CASE()
6334                         }
6335                 }
6336                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
6337                         case ZEND_FETCH_GLOBAL:
6338                                 if (IS_CONST != IS_TMP_VAR) {
6339 
6340                                 }
6341                                 break;
6342                         case ZEND_FETCH_LOCAL:
6343 
6344                                 break;
6345                         case ZEND_FETCH_STATIC:
6346                                 zval_update_constant(retval, 1 TSRMLS_CC);
6347                                 break;
6348                         case ZEND_FETCH_GLOBAL_LOCK:
6349                                 if (IS_CONST == IS_VAR && !free_op1.var) {
6350                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
6351                                 }
6352                                 break;
6353                 }
6354         }
6355 
6356 
6357         if (IS_CONST != IS_CONST && varname == &tmp_varname) {
6358                 zval_dtor(&tmp_varname);
6359         }
6360         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
6361                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
6362         }
6363         PZVAL_LOCK(*retval);
6364         switch (type) {
6365                 case BP_VAR_R:
6366                 case BP_VAR_IS:
6367                         EX_T(opline->result.var).var.ptr = *retval;
6368                         break;
6369                 case BP_VAR_UNSET: {
6370                         zend_free_op free_res;
6371 
6372                         PZVAL_UNLOCK(*retval, &free_res);
6373                         if (retval != &EG(uninitialized_zval_ptr)) {
6374                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
6375                         }
6376                         PZVAL_LOCK(*retval);
6377                         FREE_OP_VAR_PTR(free_res);
6378                 }
6379                 /* break missing intentionally */
6380                 default:
6381                         EX_T(opline->result.var).var.ptr_ptr = retval;
6382                         break;
6383         }
6384         CHECK_EXCEPTION();
6385         ZEND_VM_NEXT_OPCODE();
6386 }
6387 
6388 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6389 {
6390         return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6391 }
6392 
6393 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6394 {
6395         return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6396 }
6397 
6398 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6399 {
6400         return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6401 }
6402 
6403 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6404 {
6405         USE_OPLINE
6406 
6407         return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6408 }
6409 
6410 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6411 {
6412         return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6413 }
6414 
6415 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6416 {
6417         return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6418 }
6419 
6420 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6421 {
6422         USE_OPLINE
6423         zval *function_name;
6424         zend_class_entry *ce;
6425         call_slot *call = EX(call_slots) + opline->result.num;
6426 
6427         SAVE_OPLINE();
6428 
6429         if (IS_CONST == IS_CONST) {
6430                 /* no function found. try a static method in class */
6431                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
6432                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
6433                 } else {
6434                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
6435                         if (UNEXPECTED(EG(exception) != NULL)) {
6436                                 HANDLE_EXCEPTION();
6437                         }
6438                         if (UNEXPECTED(ce == NULL)) {
6439                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
6440                         }
6441                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
6442                 }
6443                 call->called_scope = ce;
6444         } else {
6445                 ce = EX_T(opline->op1.var).class_entry;
6446 
6447                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
6448                         call->called_scope = EG(called_scope);
6449                 } else {
6450                         call->called_scope = ce;
6451                 }
6452         }
6453 
6454         if (IS_CONST == IS_CONST &&
6455             IS_UNUSED == IS_CONST &&
6456             CACHED_PTR(opline->op2.literal->cache_slot)) {
6457                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
6458         } else if (IS_CONST != IS_CONST &&
6459                    IS_UNUSED == IS_CONST &&
6460                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
6461                 /* do nothing */
6462         } else if (IS_UNUSED != IS_UNUSED) {
6463                 char *function_name_strval = NULL;
6464                 int function_name_strlen = 0;
6465 
6466 
6467                 if (IS_UNUSED == IS_CONST) {
6468                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
6469                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
6470                 } else {
6471                         function_name = NULL;
6472 
6473                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
6474                                 if (UNEXPECTED(EG(exception) != NULL)) {
6475                                         HANDLE_EXCEPTION();
6476                                 }
6477                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
6478                         } else {
6479                                 function_name_strval = Z_STRVAL_P(function_name);
6480                                 function_name_strlen = Z_STRLEN_P(function_name);
6481                         }
6482                 }
6483 
6484                 if (function_name_strval) {
6485                         if (ce->get_static_method) {
6486                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
6487                         } else {
6488                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
6489                         }
6490                         if (UNEXPECTED(call->fbc == NULL)) {
6491                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
6492                         }
6493                         if (IS_UNUSED == IS_CONST &&
6494                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
6495                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
6496                                 if (IS_CONST == IS_CONST) {
6497                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
6498                                 } else {
6499                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
6500                                 }
6501                         }
6502                 }
6503                 if (IS_UNUSED != IS_CONST) {
6504 
6505                 }
6506         } else {
6507                 if (UNEXPECTED(ce->constructor == NULL)) {
6508                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
6509                 }
6510                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
6511                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
6512                 }
6513                 call->fbc = ce->constructor;
6514         }
6515 
6516         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
6517                 call->object = NULL;
6518         } else {
6519                 if (EG(This) &&
6520                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
6521                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
6522                     /* We are calling method of the other (incompatible) class,
6523                        but passing $this. This is done for compatibility with php-4. */
6524                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
6525                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
6526                         } else {
6527                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
6528                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
6529                         }
6530                 }
6531                 if ((call->object = EG(This))) {
6532                         Z_ADDREF_P(call->object);
6533                         call->called_scope = Z_OBJCE_P(call->object);
6534                 }
6535         }
6536 
6537         call->num_additional_args = 0;
6538         call->is_ctor_call = 0;
6539         EX(call) = call;
6540 
6541         CHECK_EXCEPTION();
6542         ZEND_VM_NEXT_OPCODE();
6543 }
6544 
6545 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6546 {
6547         USE_OPLINE
6548 
6549         zval *expr_ptr;
6550 
6551         SAVE_OPLINE();
6552         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
6553                 zval **expr_ptr_ptr = NULL;
6554 
6555                 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
6556                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
6557                 }
6558                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
6559                 expr_ptr = *expr_ptr_ptr;
6560                 Z_ADDREF_P(expr_ptr);
6561         } else {
6562                 expr_ptr=opline->op1.zv;
6563                 if (0) { /* temporary variable */
6564                         zval *new_expr;
6565 
6566                         ALLOC_ZVAL(new_expr);
6567                         INIT_PZVAL_COPY(new_expr, expr_ptr);
6568                         expr_ptr = new_expr;
6569                 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
6570                         zval *new_expr;
6571 
6572                         ALLOC_ZVAL(new_expr);
6573                         INIT_PZVAL_COPY(new_expr, expr_ptr);
6574                         expr_ptr = new_expr;
6575                         zendi_zval_copy_ctor(*expr_ptr);
6576 
6577                 } else if (IS_CONST == IS_CV) {
6578                         Z_ADDREF_P(expr_ptr);
6579                 }
6580         }
6581 
6582         if (IS_UNUSED != IS_UNUSED) {
6583 
6584                 zval *offset = NULL;
6585                 ulong hval;
6586 
6587                 switch (Z_TYPE_P(offset)) {
6588                         case IS_DOUBLE:
6589                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
6590                                 goto num_index;
6591                         case IS_LONG:
6592                         case IS_BOOL:
6593                                 hval = Z_LVAL_P(offset);
6594 num_index:
6595                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
6596                                 break;
6597                         case IS_STRING:
6598                                 if (IS_UNUSED == IS_CONST) {
6599                                         hval = Z_HASH_P(offset);
6600                                 } else {
6601                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
6602                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
6603                                 }
6604                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
6605                                 break;
6606                         case IS_NULL:
6607                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
6608                                 break;
6609                         default:
6610                                 zend_error(E_WARNING, "Illegal offset type");
6611                                 zval_ptr_dtor(&expr_ptr);
6612                                 /* do nothing */
6613                                 break;
6614                 }
6615 
6616         } else {
6617                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
6618         }
6619         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
6620 
6621         }
6622         CHECK_EXCEPTION();
6623         ZEND_VM_NEXT_OPCODE();
6624 }
6625 
6626 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6627 {
6628         USE_OPLINE
6629 
6630         array_init(&EX_T(opline->result.var).tmp_var);
6631         if (IS_CONST == IS_UNUSED) {
6632                 ZEND_VM_NEXT_OPCODE();
6633 #if 0 || IS_CONST != IS_UNUSED
6634         } else {
6635                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
6636 #endif
6637         }
6638 }
6639 
6640 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6641 {
6642         USE_OPLINE
6643         zval tmp, *varname;
6644         HashTable *target_symbol_table;
6645 
6646 
6647         SAVE_OPLINE();
6648         if (IS_CONST == IS_CV &&
6649             IS_UNUSED == IS_UNUSED &&
6650             (opline->extended_value & ZEND_QUICK_SET)) {
6651                 if (EG(active_symbol_table)) {
6652                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
6653 
6654                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
6655                         EX_CV(opline->op1.var) = NULL;
6656                 } else if (EX_CV(opline->op1.var)) {
6657                         zval_ptr_dtor(EX_CV(opline->op1.var));
6658                         EX_CV(opline->op1.var) = NULL;
6659                 }
6660                 CHECK_EXCEPTION();
6661                 ZEND_VM_NEXT_OPCODE();
6662         }
6663 
6664         varname = opline->op1.zv;
6665 
6666         if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
6667                 ZVAL_COPY_VALUE(&tmp, varname);
6668                 zval_copy_ctor(&tmp);
6669                 convert_to_string(&tmp);
6670                 varname = &tmp;
6671         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
6672                 Z_ADDREF_P(varname);
6673         }
6674 
6675         if (IS_UNUSED != IS_UNUSED) {
6676                 zend_class_entry *ce;
6677 
6678                 if (IS_UNUSED == IS_CONST) {
6679                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
6680                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
6681                         } else {
6682                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
6683                                 if (UNEXPECTED(EG(exception) != NULL)) {
6684                                         if (IS_CONST != IS_CONST && varname == &tmp) {
6685                                                 zval_dtor(&tmp);
6686                                         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
6687                                                 zval_ptr_dtor(&varname);
6688                                         }
6689 
6690                                         HANDLE_EXCEPTION();
6691                                 }
6692                                 if (UNEXPECTED(ce == NULL)) {
6693                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
6694                                 }
6695                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
6696                         }
6697                 } else {
6698                         ce = EX_T(opline->op2.var).class_entry;
6699                 }
6700                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
6701         } else {
6702                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
6703 
6704                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
6705                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
6706         }
6707 
6708         if (IS_CONST != IS_CONST && varname == &tmp) {
6709                 zval_dtor(&tmp);
6710         } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
6711                 zval_ptr_dtor(&varname);
6712         }
6713 
6714         CHECK_EXCEPTION();
6715         ZEND_VM_NEXT_OPCODE();
6716 }
6717 
6718 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6719 {
6720         USE_OPLINE
6721         zval **value;
6722         zend_bool isset = 1;
6723 
6724         SAVE_OPLINE();
6725         if (IS_CONST == IS_CV &&
6726             IS_UNUSED == IS_UNUSED &&
6727             (opline->extended_value & ZEND_QUICK_SET)) {
6728                 if (EX_CV(opline->op1.var)) {
6729                         value = EX_CV(opline->op1.var);
6730                 } else if (EG(active_symbol_table)) {
6731                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
6732 
6733                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
6734                                 isset = 0;
6735                         }
6736                 } else {
6737                         isset = 0;
6738                 }
6739         } else {
6740                 HashTable *target_symbol_table;
6741 
6742                 zval tmp, *varname = opline->op1.zv;
6743 
6744                 if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
6745                         ZVAL_COPY_VALUE(&tmp, varname);
6746                         zval_copy_ctor(&tmp);
6747                         convert_to_string(&tmp);
6748                         varname = &tmp;
6749                 }
6750 
6751                 if (IS_UNUSED != IS_UNUSED) {
6752                         zend_class_entry *ce;
6753 
6754                         if (IS_UNUSED == IS_CONST) {
6755                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
6756                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
6757                                 } else {
6758                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
6759                                         if (UNEXPECTED(ce == NULL)) {
6760                                                 CHECK_EXCEPTION();
6761                                                 ZEND_VM_NEXT_OPCODE();
6762                                         }
6763                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
6764                                 }
6765                         } else {
6766                                 ce = EX_T(opline->op2.var).class_entry;
6767                         }
6768                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
6769                         if (!value) {
6770                                 isset = 0;
6771                         }
6772                 } else {
6773                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
6774                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
6775                                 isset = 0;
6776                         }
6777                 }
6778 
6779                 if (IS_CONST != IS_CONST && varname == &tmp) {
6780                         zval_dtor(&tmp);
6781                 }
6782 
6783         }
6784 
6785         if (opline->extended_value & ZEND_ISSET) {
6786                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
6787                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
6788                 } else {
6789                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
6790                 }
6791         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
6792                 if (!isset || !i_zend_is_true(*value)) {
6793                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
6794                 } else {
6795                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
6796                 }
6797         }
6798 
6799         CHECK_EXCEPTION();
6800         ZEND_VM_NEXT_OPCODE();
6801 }
6802 
6803 static int ZEND_FASTCALL  ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6804 {
6805         USE_OPLINE
6806         zend_function *op_array;
6807 
6808         SAVE_OPLINE();
6809 
6810         if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void *) &op_array) == FAILURE) ||
6811             UNEXPECTED(op_array->type != ZEND_USER_FUNCTION)) {
6812                 zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
6813         }
6814 
6815         if (UNEXPECTED((op_array->common.fn_flags & ZEND_ACC_STATIC) ||
6816                         (EX(prev_execute_data) &&
6817                          EX(prev_execute_data)->function_state.function->common.fn_flags & ZEND_ACC_STATIC))) {
6818                 zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array,  EG(called_scope), NULL TSRMLS_CC);
6819         } else {
6820                 zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array,  EG(scope), EG(This) TSRMLS_CC);
6821         }
6822 
6823         CHECK_EXCEPTION();
6824         ZEND_VM_NEXT_OPCODE();
6825 }
6826 
6827 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6828 {
6829         USE_OPLINE
6830 
6831         /* The generator object is stored in return_value_ptr_ptr */
6832         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
6833 
6834         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
6835                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
6836         }
6837 
6838         /* Destroy the previously yielded value */
6839         if (generator->value) {
6840                 zval_ptr_dtor(&generator->value);
6841         }
6842 
6843         /* Destroy the previously yielded key */
6844         if (generator->key) {
6845                 zval_ptr_dtor(&generator->key);
6846         }
6847 
6848         /* Set the new yielded value */
6849         if (IS_CONST != IS_UNUSED) {
6850 
6851 
6852                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
6853                         /* Constants and temporary variables aren't yieldable by reference,
6854                          * but we still allow them with a notice. */
6855                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
6856                                 zval *value, *copy;
6857 
6858                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
6859 
6860                                 value = opline->op1.zv;
6861                                 ALLOC_ZVAL(copy);
6862                                 INIT_PZVAL_COPY(copy, value);
6863 
6864                                 /* Temporary variables don't need ctor copying */
6865                                 if (!0) {
6866                                         zval_copy_ctor(copy);
6867                                 }
6868 
6869                                 generator->value = copy;
6870                         } else {
6871                                 zval **value_ptr = NULL;
6872 
6873                                 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
6874                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
6875                                 }
6876 
6877                                 /* If a function call result is yielded and the function did
6878                                  * not return by reference we throw a notice. */
6879                                 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
6880                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
6881                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
6882                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
6883                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
6884 
6885                                         Z_ADDREF_PP(value_ptr);
6886                                         generator->value = *value_ptr;
6887                                 } else {
6888                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
6889                                         Z_ADDREF_PP(value_ptr);
6890                                         generator->value = *value_ptr;
6891                                 }
6892 
6893                         }
6894                 } else {
6895                         zval *value = opline->op1.zv;
6896 
6897                         /* Consts, temporary variables and references need copying */
6898                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
6899                                 || PZVAL_IS_REF(value)
6900                         ) {
6901                                 zval *copy;
6902 
6903                                 ALLOC_ZVAL(copy);
6904                                 INIT_PZVAL_COPY(copy, value);
6905 
6906                                 /* Temporary variables don't need ctor copying */
6907                                 if (!0) {
6908                                         zval_copy_ctor(copy);
6909                                 }
6910 
6911                                 generator->value = copy;
6912 
6913                         } else {
6914                                 if (IS_CONST == IS_CV) {
6915                                         Z_ADDREF_P(value);
6916                                 }
6917                                 generator->value = value;
6918                         }
6919                 }
6920         } else {
6921                 /* If no value was specified yield null */
6922                 Z_ADDREF(EG(uninitialized_zval));
6923                 generator->value = &EG(uninitialized_zval);
6924         }
6925 
6926         /* Set the new yielded key */
6927         if (IS_UNUSED != IS_UNUSED) {
6928 
6929                 zval *key = NULL;
6930 
6931                 /* Consts, temporary variables and references need copying */
6932                 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
6933                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
6934                 ) {
6935                         zval *copy;
6936 
6937                         ALLOC_ZVAL(copy);
6938                         INIT_PZVAL_COPY(copy, key);
6939 
6940                         /* Temporary variables don't need ctor copying */
6941                         if (!0) {
6942                                 zval_copy_ctor(copy);
6943                         }
6944 
6945                         generator->key = copy;
6946                 } else {
6947                         Z_ADDREF_P(key);
6948                         generator->key = key;
6949                 }
6950 
6951                 if (Z_TYPE_P(generator->key) == IS_LONG
6952                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
6953                 ) {
6954                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
6955                 }
6956 
6957         } else {
6958                 /* If no key was specified we use auto-increment keys */
6959                 generator->largest_used_integer_key++;
6960 
6961                 ALLOC_INIT_ZVAL(generator->key);
6962                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
6963         }
6964 
6965         if (RETURN_VALUE_USED(opline)) {
6966                 /* If the return value of yield is used set the send
6967                  * target and initialize it to NULL */
6968                 generator->send_target = &EX_T(opline->result.var).var.ptr;
6969                 Z_ADDREF(EG(uninitialized_zval));
6970                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
6971         } else {
6972                 generator->send_target = NULL;
6973         }
6974 
6975         /* We increment to the next op, so we are at the correct position when the
6976          * generator is resumed. */
6977         ZEND_VM_INC_OPCODE();
6978 
6979         /* The GOTO VM uses a local opline variable. We need to set the opline
6980          * variable in execute_data so we don't resume at an old position. */
6981         SAVE_OPLINE();
6982 
6983         ZEND_VM_RETURN();
6984 }
6985 
6986 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6987 {
6988         USE_OPLINE
6989 
6990 
6991         SAVE_OPLINE();
6992         fast_add_function(&EX_T(opline->result.var).tmp_var,
6993                 opline->op1.zv,
6994                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
6995 
6996 
6997         CHECK_EXCEPTION();
6998         ZEND_VM_NEXT_OPCODE();
6999 }
7000 
7001 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7002 {
7003         USE_OPLINE
7004 
7005 
7006         SAVE_OPLINE();
7007         fast_sub_function(&EX_T(opline->result.var).tmp_var,
7008                 opline->op1.zv,
7009                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7010 
7011 
7012         CHECK_EXCEPTION();
7013         ZEND_VM_NEXT_OPCODE();
7014 }
7015 
7016 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7017 {
7018         USE_OPLINE
7019 
7020 
7021         SAVE_OPLINE();
7022         fast_mul_function(&EX_T(opline->result.var).tmp_var,
7023                 opline->op1.zv,
7024                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7025 
7026 
7027         CHECK_EXCEPTION();
7028         ZEND_VM_NEXT_OPCODE();
7029 }
7030 
7031 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7032 {
7033         USE_OPLINE
7034 
7035 
7036         SAVE_OPLINE();
7037         fast_div_function(&EX_T(opline->result.var).tmp_var,
7038                 opline->op1.zv,
7039                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7040 
7041 
7042         CHECK_EXCEPTION();
7043         ZEND_VM_NEXT_OPCODE();
7044 }
7045 
7046 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7047 {
7048         USE_OPLINE
7049 
7050 
7051         SAVE_OPLINE();
7052         fast_mod_function(&EX_T(opline->result.var).tmp_var,
7053                 opline->op1.zv,
7054                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7055 
7056 
7057         CHECK_EXCEPTION();
7058         ZEND_VM_NEXT_OPCODE();
7059 }
7060 
7061 static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7062 {
7063         USE_OPLINE
7064 
7065 
7066         SAVE_OPLINE();
7067         shift_left_function(&EX_T(opline->result.var).tmp_var,
7068                 opline->op1.zv,
7069                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7070 
7071 
7072         CHECK_EXCEPTION();
7073         ZEND_VM_NEXT_OPCODE();
7074 }
7075 
7076 static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7077 {
7078         USE_OPLINE
7079 
7080 
7081         SAVE_OPLINE();
7082         shift_right_function(&EX_T(opline->result.var).tmp_var,
7083                 opline->op1.zv,
7084                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7085 
7086 
7087         CHECK_EXCEPTION();
7088         ZEND_VM_NEXT_OPCODE();
7089 }
7090 
7091 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7092 {
7093         USE_OPLINE
7094 
7095 
7096         SAVE_OPLINE();
7097         concat_function(&EX_T(opline->result.var).tmp_var,
7098                 opline->op1.zv,
7099                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7100 
7101 
7102         CHECK_EXCEPTION();
7103         ZEND_VM_NEXT_OPCODE();
7104 }
7105 
7106 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7107 {
7108         USE_OPLINE
7109 
7110 
7111         SAVE_OPLINE();
7112         is_identical_function(&EX_T(opline->result.var).tmp_var,
7113                 opline->op1.zv,
7114                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7115 
7116 
7117         CHECK_EXCEPTION();
7118         ZEND_VM_NEXT_OPCODE();
7119 }
7120 
7121 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7122 {
7123         USE_OPLINE
7124 
7125         zval *result = &EX_T(opline->result.var).tmp_var;
7126 
7127         SAVE_OPLINE();
7128         is_identical_function(result,
7129                 opline->op1.zv,
7130                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7131         Z_LVAL_P(result) = !Z_LVAL_P(result);
7132 
7133 
7134         CHECK_EXCEPTION();
7135         ZEND_VM_NEXT_OPCODE();
7136 }
7137 
7138 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7139 {
7140         USE_OPLINE
7141 
7142         zval *result = &EX_T(opline->result.var).tmp_var;
7143 
7144         SAVE_OPLINE();
7145         ZVAL_BOOL(result, fast_equal_function(result,
7146                 opline->op1.zv,
7147                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
7148 
7149 
7150         CHECK_EXCEPTION();
7151         ZEND_VM_NEXT_OPCODE();
7152 }
7153 
7154 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7155 {
7156         USE_OPLINE
7157 
7158         zval *result = &EX_T(opline->result.var).tmp_var;
7159 
7160         SAVE_OPLINE();
7161         ZVAL_BOOL(result, fast_not_equal_function(result,
7162                 opline->op1.zv,
7163                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
7164 
7165 
7166         CHECK_EXCEPTION();
7167         ZEND_VM_NEXT_OPCODE();
7168 }
7169 
7170 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7171 {
7172         USE_OPLINE
7173 
7174         zval *result = &EX_T(opline->result.var).tmp_var;
7175 
7176         SAVE_OPLINE();
7177         ZVAL_BOOL(result, fast_is_smaller_function(result,
7178                 opline->op1.zv,
7179                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
7180 
7181 
7182         CHECK_EXCEPTION();
7183         ZEND_VM_NEXT_OPCODE();
7184 }
7185 
7186 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7187 {
7188         USE_OPLINE
7189 
7190         zval *result = &EX_T(opline->result.var).tmp_var;
7191 
7192         SAVE_OPLINE();
7193         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
7194                 opline->op1.zv,
7195                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
7196 
7197 
7198         CHECK_EXCEPTION();
7199         ZEND_VM_NEXT_OPCODE();
7200 }
7201 
7202 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7203 {
7204         USE_OPLINE
7205 
7206 
7207         SAVE_OPLINE();
7208         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
7209                 opline->op1.zv,
7210                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7211 
7212 
7213         CHECK_EXCEPTION();
7214         ZEND_VM_NEXT_OPCODE();
7215 }
7216 
7217 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7218 {
7219         USE_OPLINE
7220 
7221 
7222         SAVE_OPLINE();
7223         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
7224                 opline->op1.zv,
7225                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7226 
7227 
7228         CHECK_EXCEPTION();
7229         ZEND_VM_NEXT_OPCODE();
7230 }
7231 
7232 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7233 {
7234         USE_OPLINE
7235 
7236 
7237         SAVE_OPLINE();
7238         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
7239                 opline->op1.zv,
7240                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7241 
7242 
7243         CHECK_EXCEPTION();
7244         ZEND_VM_NEXT_OPCODE();
7245 }
7246 
7247 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7248 {
7249         USE_OPLINE
7250 
7251 
7252         SAVE_OPLINE();
7253         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
7254                 opline->op1.zv,
7255                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7256 
7257 
7258         CHECK_EXCEPTION();
7259         ZEND_VM_NEXT_OPCODE();
7260 }
7261 
7262 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7263 {
7264         USE_OPLINE
7265 
7266         zval *container;
7267 
7268         SAVE_OPLINE();
7269         container = opline->op1.zv;
7270         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
7271 
7272         if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
7273 
7274         }
7275         CHECK_EXCEPTION();
7276         ZEND_VM_NEXT_OPCODE();
7277 }
7278 
7279 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7280 {
7281         USE_OPLINE
7282         zval *function_name;
7283         zend_class_entry *ce;
7284         call_slot *call = EX(call_slots) + opline->result.num;
7285 
7286         SAVE_OPLINE();
7287 
7288         if (IS_CONST == IS_CONST) {
7289                 /* no function found. try a static method in class */
7290                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
7291                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
7292                 } else {
7293                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
7294                         if (UNEXPECTED(EG(exception) != NULL)) {
7295                                 HANDLE_EXCEPTION();
7296                         }
7297                         if (UNEXPECTED(ce == NULL)) {
7298                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
7299                         }
7300                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
7301                 }
7302                 call->called_scope = ce;
7303         } else {
7304                 ce = EX_T(opline->op1.var).class_entry;
7305 
7306                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
7307                         call->called_scope = EG(called_scope);
7308                 } else {
7309                         call->called_scope = ce;
7310                 }
7311         }
7312 
7313         if (IS_CONST == IS_CONST &&
7314             IS_CV == IS_CONST &&
7315             CACHED_PTR(opline->op2.literal->cache_slot)) {
7316                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
7317         } else if (IS_CONST != IS_CONST &&
7318                    IS_CV == IS_CONST &&
7319                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
7320                 /* do nothing */
7321         } else if (IS_CV != IS_UNUSED) {
7322                 char *function_name_strval = NULL;
7323                 int function_name_strlen = 0;
7324 
7325 
7326                 if (IS_CV == IS_CONST) {
7327                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
7328                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
7329                 } else {
7330                         function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
7331 
7332                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7333                                 if (UNEXPECTED(EG(exception) != NULL)) {
7334                                         HANDLE_EXCEPTION();
7335                                 }
7336                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
7337                         } else {
7338                                 function_name_strval = Z_STRVAL_P(function_name);
7339                                 function_name_strlen = Z_STRLEN_P(function_name);
7340                         }
7341                 }
7342 
7343                 if (function_name_strval) {
7344                         if (ce->get_static_method) {
7345                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
7346                         } else {
7347                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
7348                         }
7349                         if (UNEXPECTED(call->fbc == NULL)) {
7350                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
7351                         }
7352                         if (IS_CV == IS_CONST &&
7353                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
7354                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
7355                                 if (IS_CONST == IS_CONST) {
7356                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
7357                                 } else {
7358                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
7359                                 }
7360                         }
7361                 }
7362                 if (IS_CV != IS_CONST) {
7363 
7364                 }
7365         } else {
7366                 if (UNEXPECTED(ce->constructor == NULL)) {
7367                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
7368                 }
7369                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
7370                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
7371                 }
7372                 call->fbc = ce->constructor;
7373         }
7374 
7375         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
7376                 call->object = NULL;
7377         } else {
7378                 if (EG(This) &&
7379                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
7380                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
7381                     /* We are calling method of the other (incompatible) class,
7382                        but passing $this. This is done for compatibility with php-4. */
7383                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
7384                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
7385                         } else {
7386                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
7387                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
7388                         }
7389                 }
7390                 if ((call->object = EG(This))) {
7391                         Z_ADDREF_P(call->object);
7392                         call->called_scope = Z_OBJCE_P(call->object);
7393                 }
7394         }
7395 
7396         call->num_additional_args = 0;
7397         call->is_ctor_call = 0;
7398         EX(call) = call;
7399 
7400         CHECK_EXCEPTION();
7401         ZEND_VM_NEXT_OPCODE();
7402 }
7403 
7404 static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7405 {
7406         USE_OPLINE
7407         zend_class_entry *ce, *catch_ce;
7408         zval *exception;
7409 
7410         SAVE_OPLINE();
7411         /* Check whether an exception has been thrown, if not, jump over code */
7412         zend_exception_restore(TSRMLS_C);
7413         if (EG(exception) == NULL) {
7414                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
7415                 ZEND_VM_CONTINUE(); /* CHECK_ME */
7416         }
7417         if (CACHED_PTR(opline->op1.literal->cache_slot)) {
7418                 catch_ce = CACHED_PTR(opline->op1.literal->cache_slot);
7419         } else {
7420                 catch_ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
7421 
7422                 CACHE_PTR(opline->op1.literal->cache_slot, catch_ce);
7423         }
7424         ce = Z_OBJCE_P(EG(exception));
7425 
7426 #ifdef HAVE_DTRACE
7427         if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
7428                 DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
7429         }
7430 #endif /* HAVE_DTRACE */
7431 
7432         if (ce != catch_ce) {
7433                 if (!instanceof_function(ce, catch_ce TSRMLS_CC)) {
7434                         if (opline->result.num) {
7435                                 zend_throw_exception_internal(NULL TSRMLS_CC);
7436                                 HANDLE_EXCEPTION();
7437                         }
7438                         ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
7439                         ZEND_VM_CONTINUE(); /* CHECK_ME */
7440                 }
7441         }
7442 
7443         exception = EG(exception);
7444         if (!EG(active_symbol_table)) {
7445                 if (EX_CV(opline->op2.var)) {
7446                         zval_ptr_dtor(EX_CV(opline->op2.var));
7447                 }
7448                 EX_CV(opline->op2.var) = (zval**)EX_CV_NUM(execute_data, EX(op_array)->last_var + opline->op2.var);
7449                 *EX_CV(opline->op2.var) = EG(exception);
7450         } else {
7451                 zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.var);
7452                 zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value,
7453                     &EG(exception), sizeof(zval *), (void**)&EX_CV(opline->op2.var));
7454         }
7455         if (UNEXPECTED(EG(exception) != exception)) {
7456                 Z_ADDREF_P(EG(exception));
7457                 HANDLE_EXCEPTION();
7458         } else {
7459                 EG(exception) = NULL;
7460                 ZEND_VM_NEXT_OPCODE();
7461         }
7462 }
7463 
7464 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7465 {
7466         USE_OPLINE
7467 
7468 
7469         SAVE_OPLINE();
7470         is_equal_function(&EX_T(opline->result.var).tmp_var,
7471                                  opline->op1.zv,
7472                                  _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7473 
7474         CHECK_EXCEPTION();
7475         ZEND_VM_NEXT_OPCODE();
7476 }
7477 
7478 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7479 {
7480         USE_OPLINE
7481 
7482         zval *expr_ptr;
7483 
7484         SAVE_OPLINE();
7485         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
7486                 zval **expr_ptr_ptr = NULL;
7487 
7488                 if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
7489                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
7490                 }
7491                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
7492                 expr_ptr = *expr_ptr_ptr;
7493                 Z_ADDREF_P(expr_ptr);
7494         } else {
7495                 expr_ptr=opline->op1.zv;
7496                 if (0) { /* temporary variable */
7497                         zval *new_expr;
7498 
7499                         ALLOC_ZVAL(new_expr);
7500                         INIT_PZVAL_COPY(new_expr, expr_ptr);
7501                         expr_ptr = new_expr;
7502                 } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
7503                         zval *new_expr;
7504 
7505                         ALLOC_ZVAL(new_expr);
7506                         INIT_PZVAL_COPY(new_expr, expr_ptr);
7507                         expr_ptr = new_expr;
7508                         zendi_zval_copy_ctor(*expr_ptr);
7509 
7510                 } else if (IS_CONST == IS_CV) {
7511                         Z_ADDREF_P(expr_ptr);
7512                 }
7513         }
7514 
7515         if (IS_CV != IS_UNUSED) {
7516 
7517                 zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
7518                 ulong hval;
7519 
7520                 switch (Z_TYPE_P(offset)) {
7521                         case IS_DOUBLE:
7522                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
7523                                 goto num_index;
7524                         case IS_LONG:
7525                         case IS_BOOL:
7526                                 hval = Z_LVAL_P(offset);
7527 num_index:
7528                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
7529                                 break;
7530                         case IS_STRING:
7531                                 if (IS_CV == IS_CONST) {
7532                                         hval = Z_HASH_P(offset);
7533                                 } else {
7534                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
7535                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
7536                                 }
7537                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
7538                                 break;
7539                         case IS_NULL:
7540                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
7541                                 break;
7542                         default:
7543                                 zend_error(E_WARNING, "Illegal offset type");
7544                                 zval_ptr_dtor(&expr_ptr);
7545                                 /* do nothing */
7546                                 break;
7547                 }
7548 
7549         } else {
7550                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
7551         }
7552         if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
7553 
7554         }
7555         CHECK_EXCEPTION();
7556         ZEND_VM_NEXT_OPCODE();
7557 }
7558 
7559 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7560 {
7561         USE_OPLINE
7562 
7563         array_init(&EX_T(opline->result.var).tmp_var);
7564         if (IS_CONST == IS_UNUSED) {
7565                 ZEND_VM_NEXT_OPCODE();
7566 #if 0 || IS_CONST != IS_UNUSED
7567         } else {
7568                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7569 #endif
7570         }
7571 }
7572 
7573 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7574 {
7575         USE_OPLINE
7576 
7577         /* The generator object is stored in return_value_ptr_ptr */
7578         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
7579 
7580         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
7581                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
7582         }
7583 
7584         /* Destroy the previously yielded value */
7585         if (generator->value) {
7586                 zval_ptr_dtor(&generator->value);
7587         }
7588 
7589         /* Destroy the previously yielded key */
7590         if (generator->key) {
7591                 zval_ptr_dtor(&generator->key);
7592         }
7593 
7594         /* Set the new yielded value */
7595         if (IS_CONST != IS_UNUSED) {
7596 
7597 
7598                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
7599                         /* Constants and temporary variables aren't yieldable by reference,
7600                          * but we still allow them with a notice. */
7601                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
7602                                 zval *value, *copy;
7603 
7604                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7605 
7606                                 value = opline->op1.zv;
7607                                 ALLOC_ZVAL(copy);
7608                                 INIT_PZVAL_COPY(copy, value);
7609 
7610                                 /* Temporary variables don't need ctor copying */
7611                                 if (!0) {
7612                                         zval_copy_ctor(copy);
7613                                 }
7614 
7615                                 generator->value = copy;
7616                         } else {
7617                                 zval **value_ptr = NULL;
7618 
7619                                 if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
7620                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
7621                                 }
7622 
7623                                 /* If a function call result is yielded and the function did
7624                                  * not return by reference we throw a notice. */
7625                                 if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
7626                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
7627                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
7628                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
7629                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7630 
7631                                         Z_ADDREF_PP(value_ptr);
7632                                         generator->value = *value_ptr;
7633                                 } else {
7634                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
7635                                         Z_ADDREF_PP(value_ptr);
7636                                         generator->value = *value_ptr;
7637                                 }
7638 
7639                         }
7640                 } else {
7641                         zval *value = opline->op1.zv;
7642 
7643                         /* Consts, temporary variables and references need copying */
7644                         if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
7645                                 || PZVAL_IS_REF(value)
7646                         ) {
7647                                 zval *copy;
7648 
7649                                 ALLOC_ZVAL(copy);
7650                                 INIT_PZVAL_COPY(copy, value);
7651 
7652                                 /* Temporary variables don't need ctor copying */
7653                                 if (!0) {
7654                                         zval_copy_ctor(copy);
7655                                 }
7656 
7657                                 generator->value = copy;
7658 
7659                         } else {
7660                                 if (IS_CONST == IS_CV) {
7661                                         Z_ADDREF_P(value);
7662                                 }
7663                                 generator->value = value;
7664                         }
7665                 }
7666         } else {
7667                 /* If no value was specified yield null */
7668                 Z_ADDREF(EG(uninitialized_zval));
7669                 generator->value = &EG(uninitialized_zval);
7670         }
7671 
7672         /* Set the new yielded key */
7673         if (IS_CV != IS_UNUSED) {
7674 
7675                 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
7676 
7677                 /* Consts, temporary variables and references need copying */
7678                 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
7679                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
7680                 ) {
7681                         zval *copy;
7682 
7683                         ALLOC_ZVAL(copy);
7684                         INIT_PZVAL_COPY(copy, key);
7685 
7686                         /* Temporary variables don't need ctor copying */
7687                         if (!0) {
7688                                 zval_copy_ctor(copy);
7689                         }
7690 
7691                         generator->key = copy;
7692                 } else {
7693                         Z_ADDREF_P(key);
7694                         generator->key = key;
7695                 }
7696 
7697                 if (Z_TYPE_P(generator->key) == IS_LONG
7698                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
7699                 ) {
7700                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
7701                 }
7702 
7703         } else {
7704                 /* If no key was specified we use auto-increment keys */
7705                 generator->largest_used_integer_key++;
7706 
7707                 ALLOC_INIT_ZVAL(generator->key);
7708                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
7709         }
7710 
7711         if (RETURN_VALUE_USED(opline)) {
7712                 /* If the return value of yield is used set the send
7713                  * target and initialize it to NULL */
7714                 generator->send_target = &EX_T(opline->result.var).var.ptr;
7715                 Z_ADDREF(EG(uninitialized_zval));
7716                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
7717         } else {
7718                 generator->send_target = NULL;
7719         }
7720 
7721         /* We increment to the next op, so we are at the correct position when the
7722          * generator is resumed. */
7723         ZEND_VM_INC_OPCODE();
7724 
7725         /* The GOTO VM uses a local opline variable. We need to set the opline
7726          * variable in execute_data so we don't resume at an old position. */
7727         SAVE_OPLINE();
7728 
7729         ZEND_VM_RETURN();
7730 }
7731 
7732 static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7733 {
7734         USE_OPLINE
7735 
7736 
7737         SAVE_OPLINE();
7738         pow_function(&EX_T(opline->result.var).tmp_var,
7739                 opline->op1.zv,
7740                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
7741 
7742 
7743         CHECK_EXCEPTION();
7744         ZEND_VM_NEXT_OPCODE();
7745 }
7746 
7747 static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7748 {
7749         USE_OPLINE
7750         zend_free_op free_op1;
7751 
7752         SAVE_OPLINE();
7753         bitwise_not_function(&EX_T(opline->result.var).tmp_var,
7754                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
7755         zval_dtor(free_op1.var);
7756         CHECK_EXCEPTION();
7757         ZEND_VM_NEXT_OPCODE();
7758 }
7759 
7760 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7761 {
7762         USE_OPLINE
7763         zend_free_op free_op1;
7764 
7765         SAVE_OPLINE();
7766         boolean_not_function(&EX_T(opline->result.var).tmp_var,
7767                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
7768         zval_dtor(free_op1.var);
7769         CHECK_EXCEPTION();
7770         ZEND_VM_NEXT_OPCODE();
7771 }
7772 
7773 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7774 {
7775         USE_OPLINE
7776         zend_free_op free_op1;
7777         zval *z;
7778 
7779         SAVE_OPLINE();
7780         z = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7781 
7782         if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
7783                 INIT_PZVAL(z);
7784         }
7785         zend_print_variable(z);
7786 
7787         zval_dtor(free_op1.var);
7788         CHECK_EXCEPTION();
7789         ZEND_VM_NEXT_OPCODE();
7790 }
7791 
7792 static int ZEND_FASTCALL  ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7793 {
7794         USE_OPLINE
7795 
7796         ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
7797         return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
7798 }
7799 
7800 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7801 {
7802         USE_OPLINE
7803         zend_free_op free_op1;
7804         zval *val;
7805         int ret;
7806 
7807         SAVE_OPLINE();
7808         val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7809 
7810         if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7811                 ret = Z_LVAL_P(val);
7812         } else {
7813                 ret = i_zend_is_true(val);
7814                 zval_dtor(free_op1.var);
7815                 if (UNEXPECTED(EG(exception) != NULL)) {
7816                         HANDLE_EXCEPTION();
7817                 }
7818         }
7819         if (!ret) {
7820 #if DEBUG_ZEND>=2
7821                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
7822 #endif
7823                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
7824                 ZEND_VM_CONTINUE();
7825         }
7826 
7827         ZEND_VM_NEXT_OPCODE();
7828 }
7829 
7830 static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7831 {
7832         USE_OPLINE
7833         zend_free_op free_op1;
7834         zval *val;
7835         int ret;
7836 
7837         SAVE_OPLINE();
7838         val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7839 
7840         if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7841                 ret = Z_LVAL_P(val);
7842         } else {
7843                 ret = i_zend_is_true(val);
7844                 zval_dtor(free_op1.var);
7845                 if (UNEXPECTED(EG(exception) != NULL)) {
7846                         HANDLE_EXCEPTION();
7847                 }
7848         }
7849         if (ret) {
7850 #if DEBUG_ZEND>=2
7851                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
7852 #endif
7853                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
7854                 ZEND_VM_CONTINUE();
7855         }
7856 
7857         ZEND_VM_NEXT_OPCODE();
7858 }
7859 
7860 static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7861 {
7862         USE_OPLINE
7863         zend_free_op free_op1;
7864         zval *val;
7865         int retval;
7866 
7867         SAVE_OPLINE();
7868         val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7869 
7870         if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7871                 retval = Z_LVAL_P(val);
7872         } else {
7873                 retval = i_zend_is_true(val);
7874                 zval_dtor(free_op1.var);
7875                 if (UNEXPECTED(EG(exception) != NULL)) {
7876                         HANDLE_EXCEPTION();
7877                 }
7878         }
7879         if (EXPECTED(retval != 0)) {
7880 #if DEBUG_ZEND>=2
7881                 printf("Conditional jmp on true to %d\n", opline->extended_value);
7882 #endif
7883                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
7884                 ZEND_VM_CONTINUE(); /* CHECK_ME */
7885         } else {
7886 #if DEBUG_ZEND>=2
7887                 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
7888 #endif
7889                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
7890                 ZEND_VM_CONTINUE(); /* CHECK_ME */
7891         }
7892 }
7893 
7894 static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7895 {
7896         USE_OPLINE
7897         zend_free_op free_op1;
7898         zval *val;
7899         int retval;
7900 
7901         SAVE_OPLINE();
7902         val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7903 
7904         if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7905                 retval = Z_LVAL_P(val);
7906         } else {
7907                 retval = i_zend_is_true(val);
7908                 zval_dtor(free_op1.var);
7909                 if (UNEXPECTED(EG(exception) != NULL)) {
7910                         HANDLE_EXCEPTION();
7911                 }
7912         }
7913         Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
7914         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
7915         if (!retval) {
7916 #if DEBUG_ZEND>=2
7917                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
7918 #endif
7919                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
7920                 ZEND_VM_CONTINUE();
7921         }
7922         ZEND_VM_NEXT_OPCODE();
7923 }
7924 
7925 static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7926 {
7927         USE_OPLINE
7928         zend_free_op free_op1;
7929         zval *val;
7930         int retval;
7931 
7932         SAVE_OPLINE();
7933         val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7934 
7935         if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
7936                 retval = Z_LVAL_P(val);
7937         } else {
7938                 retval = i_zend_is_true(val);
7939                 zval_dtor(free_op1.var);
7940                 if (UNEXPECTED(EG(exception) != NULL)) {
7941                         HANDLE_EXCEPTION();
7942                 }
7943         }
7944         Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
7945         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
7946         if (retval) {
7947 #if DEBUG_ZEND>=2
7948                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
7949 #endif
7950                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
7951                 ZEND_VM_CONTINUE();
7952         }
7953         ZEND_VM_NEXT_OPCODE();
7954 }
7955 
7956 static int ZEND_FASTCALL  ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7957 {
7958         USE_OPLINE
7959 
7960         SAVE_OPLINE();
7961         if (IS_TMP_VAR == IS_TMP_VAR) {
7962                 zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
7963         } else {
7964                 zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
7965         }
7966         CHECK_EXCEPTION();
7967         ZEND_VM_NEXT_OPCODE();
7968 }
7969 
7970 static int ZEND_FASTCALL  ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7971 {
7972         USE_OPLINE
7973         zval *retval_ptr;
7974         zend_free_op free_op1;
7975 
7976         SAVE_OPLINE();
7977         retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
7978 
7979         if (!EG(return_value_ptr_ptr)) {
7980                 zval_dtor(free_op1.var);
7981         } else {
7982                 if (IS_TMP_VAR == IS_CONST ||
7983                     IS_TMP_VAR == IS_TMP_VAR ||
7984                     PZVAL_IS_REF(retval_ptr)) {
7985                         zval *ret;
7986 
7987                         ALLOC_ZVAL(ret);
7988                         INIT_PZVAL_COPY(ret, retval_ptr);
7989                         if (IS_TMP_VAR != IS_TMP_VAR) {
7990                                 zval_copy_ctor(ret);
7991                         }
7992                         *EG(return_value_ptr_ptr) = ret;
7993 
7994                 } else if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) &&
7995                            retval_ptr == &EG(uninitialized_zval)) {
7996                         zval *ret;
7997 
7998                         if (IS_TMP_VAR == IS_VAR) {
7999                                 Z_DELREF_P(retval_ptr);
8000                         }
8001                         ALLOC_INIT_ZVAL(ret);
8002                         *EG(return_value_ptr_ptr) = ret;
8003                 } else {
8004                         *EG(return_value_ptr_ptr) = retval_ptr;
8005                         if (IS_TMP_VAR == IS_CV) {
8006                                 Z_ADDREF_P(retval_ptr);
8007                         }
8008                 }
8009         }
8010         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8011 }
8012 
8013 static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8014 {
8015         USE_OPLINE
8016         zval *retval_ptr;
8017         zval **retval_ptr_ptr;
8018         zend_free_op free_op1;
8019 
8020         SAVE_OPLINE();
8021 
8022         do {
8023                 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR ||
8024                     (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
8025                         /* Not supposed to happen, but we'll allow it */
8026                         zend_error(E_NOTICE, "Only variable references should be returned by reference");
8027 
8028                         retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8029                         if (!EG(return_value_ptr_ptr)) {
8030                                 if (IS_TMP_VAR == IS_TMP_VAR) {
8031                                         zval_dtor(free_op1.var);
8032                                 }
8033                         } else if (!1) { /* Not a temp var */
8034                                 zval *ret;
8035 
8036                                 ALLOC_ZVAL(ret);
8037                                 INIT_PZVAL_COPY(ret, retval_ptr);
8038                                 zval_copy_ctor(ret);
8039                                 *EG(return_value_ptr_ptr) = ret;
8040                         } else {
8041                                 zval *ret;
8042 
8043                                 ALLOC_ZVAL(ret);
8044                                 INIT_PZVAL_COPY(ret, retval_ptr);
8045                                 *EG(return_value_ptr_ptr) = ret;
8046                         }
8047                         break;
8048                 }
8049 
8050                 retval_ptr_ptr = NULL;
8051 
8052                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
8053                         zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
8054                 }
8055 
8056                 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
8057                         if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
8058                             EX_T(opline->op1.var).var.fcall_returned_reference) {
8059                         } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
8060                                 zend_error(E_NOTICE, "Only variable references should be returned by reference");
8061                                 if (EG(return_value_ptr_ptr)) {
8062                                         zval *ret;
8063 
8064                                         ALLOC_ZVAL(ret);
8065                                         INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
8066                                         zval_copy_ctor(ret);
8067                                         *EG(return_value_ptr_ptr) = ret;
8068                                 }
8069                                 break;
8070                         }
8071                 }
8072 
8073                 if (EG(return_value_ptr_ptr)) {
8074                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
8075                         Z_ADDREF_PP(retval_ptr_ptr);
8076 
8077                         *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
8078                 }
8079         } while (0);
8080 
8081         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
8082 }
8083 
8084 static int ZEND_FASTCALL  ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8085 {
8086         USE_OPLINE
8087         zval *value;
8088         zval *exception;
8089         zend_free_op free_op1;
8090 
8091         SAVE_OPLINE();
8092         value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8093 
8094         if (IS_TMP_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
8095                 if (UNEXPECTED(EG(exception) != NULL)) {
8096                         HANDLE_EXCEPTION();
8097                 }
8098                 zend_error_noreturn(E_ERROR, "Can only throw objects");
8099         }
8100 
8101         zend_exception_save(TSRMLS_C);
8102         /* Not sure if a complete copy is what we want here */
8103         ALLOC_ZVAL(exception);
8104         INIT_PZVAL_COPY(exception, value);
8105         if (!1) {
8106                 zval_copy_ctor(exception);
8107         }
8108 
8109         zend_throw_exception_object(exception TSRMLS_CC);
8110         zend_exception_restore(TSRMLS_C);
8111 
8112         HANDLE_EXCEPTION();
8113 }
8114 
8115 static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8116 {
8117         USE_OPLINE
8118 
8119         SAVE_OPLINE();
8120         if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
8121                 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
8122                         zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.num);
8123                 }
8124         }
8125 
8126         {
8127                 zval *valptr;
8128                 zval *value;
8129                 zend_free_op free_op1;
8130 
8131                 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8132 
8133                 ALLOC_ZVAL(valptr);
8134                 INIT_PZVAL_COPY(valptr, value);
8135                 if (!1) {
8136                         zval_copy_ctor(valptr);
8137                 }
8138                 zend_vm_stack_push(valptr TSRMLS_CC);
8139 
8140         }
8141         CHECK_EXCEPTION();
8142         ZEND_VM_NEXT_OPCODE();
8143 }
8144 
8145 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8146 {
8147         USE_OPLINE
8148         zend_free_op free_op1;
8149         zval *retval = &EX_T(opline->result.var).tmp_var;
8150 
8151         SAVE_OPLINE();
8152         /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
8153         ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)));
8154         zval_dtor(free_op1.var);
8155 
8156         CHECK_EXCEPTION();
8157         ZEND_VM_NEXT_OPCODE();
8158 }
8159 
8160 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8161 {
8162         USE_OPLINE
8163         zend_free_op free_op1;
8164         zval *obj;
8165         zend_class_entry *ce;
8166         zend_function *clone;
8167         zend_object_clone_obj_t clone_call;
8168 
8169         SAVE_OPLINE();
8170         obj = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8171 
8172         if (IS_TMP_VAR == IS_CONST ||
8173             UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
8174                 if (UNEXPECTED(EG(exception) != NULL)) {
8175                         HANDLE_EXCEPTION();
8176                 }
8177                 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
8178         }
8179 
8180         ce = Z_OBJCE_P(obj);
8181         clone = ce ? ce->clone : NULL;
8182         clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
8183         if (UNEXPECTED(clone_call == NULL)) {
8184                 if (ce) {
8185                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
8186                 } else {
8187                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
8188                 }
8189         }
8190 
8191         if (ce && clone) {
8192                 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
8193                         /* Ensure that if we're calling a private function, we're allowed to do so.
8194                          */
8195                         if (UNEXPECTED(ce != EG(scope))) {
8196                                 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
8197                         }
8198                 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
8199                         /* Ensure that if we're calling a protected function, we're allowed to do so.
8200                          */
8201                         if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
8202                                 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
8203                         }
8204                 }
8205         }
8206 
8207         if (EXPECTED(EG(exception) == NULL)) {
8208                 zval *retval;
8209 
8210                 ALLOC_ZVAL(retval);
8211                 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
8212                 Z_TYPE_P(retval) = IS_OBJECT;
8213                 Z_SET_REFCOUNT_P(retval, 1);
8214                 Z_SET_ISREF_P(retval);
8215                 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
8216                         zval_ptr_dtor(&retval);
8217                 } else {
8218                         EX_T(opline->result.var).var.ptr = retval;
8219                 }
8220         }
8221 
8222         CHECK_EXCEPTION();
8223         ZEND_VM_NEXT_OPCODE();
8224 }
8225 
8226 static int ZEND_FASTCALL  ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8227 {
8228         USE_OPLINE
8229         zend_free_op free_op1;
8230         zval *expr;
8231         zval *result = &EX_T(opline->result.var).tmp_var;
8232 
8233         SAVE_OPLINE();
8234         expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8235 
8236         if (opline->extended_value != IS_STRING) {
8237                 ZVAL_COPY_VALUE(result, expr);
8238                 if (!1) {
8239                         zendi_zval_copy_ctor(*result);
8240                 }
8241         }
8242         switch (opline->extended_value) {
8243                 case IS_NULL:
8244                         convert_to_null(result);
8245                         break;
8246                 case IS_BOOL:
8247                         convert_to_boolean(result);
8248                         break;
8249                 case IS_LONG:
8250                         convert_to_long(result);
8251                         break;
8252                 case IS_DOUBLE:
8253                         convert_to_double(result);
8254                         break;
8255                 case IS_STRING: {
8256                         zval var_copy;
8257                         int use_copy;
8258 
8259                         zend_make_printable_zval(expr, &var_copy, &use_copy);
8260                         if (use_copy) {
8261                                 ZVAL_COPY_VALUE(result, &var_copy);
8262                                 if (1) {
8263                                         zval_dtor(free_op1.var);
8264                                 }
8265                         } else {
8266                                 ZVAL_COPY_VALUE(result, expr);
8267                                 if (!1) {
8268                                         zendi_zval_copy_ctor(*result);
8269                                 }
8270                         }
8271                         break;
8272                 }
8273                 case IS_ARRAY:
8274                         convert_to_array(result);
8275                         break;
8276                 case IS_OBJECT:
8277                         convert_to_object(result);
8278                         break;
8279         }
8280 
8281         CHECK_EXCEPTION();
8282         ZEND_VM_NEXT_OPCODE();
8283 }
8284 
8285 static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8286 {
8287         USE_OPLINE
8288         zend_op_array *new_op_array=NULL;
8289         zend_free_op free_op1;
8290         zval *inc_filename;
8291         zval *tmp_inc_filename = NULL;
8292         zend_bool failure_retval=0;
8293 
8294         SAVE_OPLINE();
8295         inc_filename = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8296 
8297         if (inc_filename->type!=IS_STRING) {
8298                 MAKE_STD_ZVAL(tmp_inc_filename);
8299                 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
8300                 zval_copy_ctor(tmp_inc_filename);
8301                 convert_to_string(tmp_inc_filename);
8302                 inc_filename = tmp_inc_filename;
8303         }
8304 
8305         if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
8306                 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
8307                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8308                 } else {
8309                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8310                 }
8311         } else {
8312                 switch (opline->extended_value) {
8313                         case ZEND_INCLUDE_ONCE:
8314                         case ZEND_REQUIRE_ONCE: {
8315                                         zend_file_handle file_handle;
8316                                         char *resolved_path;
8317 
8318                                         resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
8319                                         if (resolved_path) {
8320                                                 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
8321                                         } else {
8322                                                 resolved_path = Z_STRVAL_P(inc_filename);
8323                                         }
8324 
8325                                         if (failure_retval) {
8326                                                 /* do nothing, file already included */
8327                                         } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
8328 
8329                                                 if (!file_handle.opened_path) {
8330                                                         file_handle.opened_path = estrdup(resolved_path);
8331                                                 }
8332 
8333                                                 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
8334                                                         new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
8335                                                         zend_destroy_file_handle(&file_handle TSRMLS_CC);
8336                                                 } else {
8337                                                         zend_file_handle_dtor(&file_handle TSRMLS_CC);
8338                                                         failure_retval=1;
8339                                                 }
8340                                         } else {
8341                                                 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
8342                                                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8343                                                 } else {
8344                                                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
8345                                                 }
8346                                         }
8347                                         if (resolved_path != Z_STRVAL_P(inc_filename)) {
8348                                                 efree(resolved_path);
8349                                         }
8350                                 }
8351                                 break;
8352                         case ZEND_INCLUDE:
8353                         case ZEND_REQUIRE:
8354                                 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
8355                                 break;
8356                         case ZEND_EVAL: {
8357                                         char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
8358 
8359                                         new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
8360                                         efree(eval_desc);
8361                                 }
8362                                 break;
8363                         EMPTY_SWITCH_DEFAULT_CASE()
8364                 }
8365         }
8366         if (tmp_inc_filename) {
8367                 zval_ptr_dtor(&tmp_inc_filename);
8368         }
8369         zval_dtor(free_op1.var);
8370         if (UNEXPECTED(EG(exception) != NULL)) {
8371                 HANDLE_EXCEPTION();
8372         } else if (EXPECTED(new_op_array != NULL)) {
8373                 EX(original_return_value) = EG(return_value_ptr_ptr);
8374                 EG(active_op_array) = new_op_array;
8375                 if (RETURN_VALUE_USED(opline)) {
8376                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8377                         EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
8378                 } else {
8379                         EG(return_value_ptr_ptr) = NULL;
8380                 }
8381 
8382                 EX(function_state).function = (zend_function *) new_op_array;
8383                 EX(object) = NULL;
8384 
8385                 if (!EG(active_symbol_table)) {
8386                         zend_rebuild_symbol_table(TSRMLS_C);
8387                 }
8388 
8389                 if (EXPECTED(zend_execute_ex == execute_ex)) {
8390                         ZEND_VM_ENTER();
8391                 } else {
8392                         zend_execute(new_op_array TSRMLS_CC);
8393                 }
8394 
8395                 EX(function_state).function = (zend_function *) EX(op_array);
8396 
8397                 EG(opline_ptr) = &EX(opline);
8398                 EG(active_op_array) = EX(op_array);
8399                 EG(return_value_ptr_ptr) = EX(original_return_value);
8400                 destroy_op_array(new_op_array TSRMLS_CC);
8401                 efree(new_op_array);
8402                 if (UNEXPECTED(EG(exception) != NULL)) {
8403                         zend_throw_exception_internal(NULL TSRMLS_CC);
8404                         HANDLE_EXCEPTION();
8405                 }
8406 
8407         } else if (RETURN_VALUE_USED(opline)) {
8408                 zval *retval;
8409 
8410                 ALLOC_ZVAL(retval);
8411                 ZVAL_BOOL(retval, failure_retval);
8412                 INIT_PZVAL(retval);
8413                 EX_T(opline->result.var).var.ptr = retval;
8414         }
8415         ZEND_VM_NEXT_OPCODE();
8416 }
8417 
8418 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8419 {
8420         USE_OPLINE
8421         zend_free_op free_op1;
8422         zval *array_ptr, **array_ptr_ptr;
8423         HashTable *fe_ht;
8424         zend_object_iterator *iter = NULL;
8425         zend_class_entry *ce = NULL;
8426         zend_bool is_empty = 0;
8427 
8428         SAVE_OPLINE();
8429 
8430         if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) &&
8431             (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
8432                 array_ptr_ptr = NULL;
8433                 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
8434                         MAKE_STD_ZVAL(array_ptr);
8435                         ZVAL_NULL(array_ptr);
8436                 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
8437                         if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
8438                                 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
8439                                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
8440                         }
8441 
8442                         ce = Z_OBJCE_PP(array_ptr_ptr);
8443                         if (!ce || ce->get_iterator == NULL) {
8444                                 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
8445                                 Z_ADDREF_PP(array_ptr_ptr);
8446                         }
8447                         array_ptr = *array_ptr_ptr;
8448                 } else {
8449                         if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
8450                                 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
8451                                 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
8452                                         Z_SET_ISREF_PP(array_ptr_ptr);
8453                                 }
8454                         }
8455                         array_ptr = *array_ptr_ptr;
8456                         Z_ADDREF_P(array_ptr);
8457                 }
8458         } else {
8459                 array_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8460                 if (1) { /* IS_TMP_VAR */
8461                         zval *tmp;
8462 
8463                         ALLOC_ZVAL(tmp);
8464                         INIT_PZVAL_COPY(tmp, array_ptr);
8465                         array_ptr = tmp;
8466                         if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
8467                                 ce = Z_OBJCE_P(array_ptr);
8468                                 if (ce && ce->get_iterator) {
8469                                         Z_DELREF_P(array_ptr);
8470                                 }
8471                         }
8472                 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
8473                         ce = Z_OBJCE_P(array_ptr);
8474                         if (!ce || !ce->get_iterator) {
8475                                 if (IS_TMP_VAR == IS_CV) {
8476                                         Z_ADDREF_P(array_ptr);
8477                                 }
8478                         }
8479                 } else if (IS_TMP_VAR == IS_CONST ||
8480                            (IS_TMP_VAR == IS_CV &&
8481                             !Z_ISREF_P(array_ptr) &&
8482                             Z_REFCOUNT_P(array_ptr) > 1) ||
8483                            (IS_TMP_VAR == IS_VAR &&
8484                             !Z_ISREF_P(array_ptr) &&
8485                             Z_REFCOUNT_P(array_ptr) > 2)) {
8486                         zval *tmp;
8487 
8488                         if (IS_TMP_VAR == IS_VAR) {
8489                                 Z_DELREF_P(array_ptr);
8490                         }
8491                         ALLOC_ZVAL(tmp);
8492                         INIT_PZVAL_COPY(tmp, array_ptr);
8493                         zval_copy_ctor(tmp);
8494                         array_ptr = tmp;
8495                 } else if (IS_TMP_VAR == IS_CV) {
8496                         Z_ADDREF_P(array_ptr);
8497                 }
8498         }
8499 
8500         if (ce && ce->get_iterator) {
8501                 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
8502 
8503                 if (IS_TMP_VAR == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
8504 
8505                 }
8506                 if (iter && EXPECTED(EG(exception) == NULL)) {
8507                         array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
8508                 } else {
8509                         if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8510 
8511                         }
8512                         if (!EG(exception)) {
8513                                 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
8514                         }
8515                         zend_throw_exception_internal(NULL TSRMLS_CC);
8516                         HANDLE_EXCEPTION();
8517                 }
8518         }
8519 
8520         EX_T(opline->result.var).fe.ptr = array_ptr;
8521 
8522         if (iter) {
8523                 iter->index = 0;
8524                 if (iter->funcs->rewind) {
8525                         iter->funcs->rewind(iter TSRMLS_CC);
8526                         if (UNEXPECTED(EG(exception) != NULL)) {
8527                                 zval_ptr_dtor(&array_ptr);
8528                                 if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8529 
8530                                 }
8531                                 HANDLE_EXCEPTION();
8532                         }
8533                 }
8534                 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
8535                 if (UNEXPECTED(EG(exception) != NULL)) {
8536                         zval_ptr_dtor(&array_ptr);
8537                         if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8538 
8539                         }
8540                         HANDLE_EXCEPTION();
8541                 }
8542                 iter->index = -1; /* will be set to 0 before using next handler */
8543         } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
8544                 zend_hash_internal_pointer_reset(fe_ht);
8545                 if (ce) {
8546                         zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
8547                         while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
8548                                 char *str_key;
8549                                 uint str_key_len;
8550                                 ulong int_key;
8551                                 zend_uchar key_type;
8552 
8553                                 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
8554                                 if (key_type != HASH_KEY_NON_EXISTENT &&
8555                                         (key_type == HASH_KEY_IS_LONG ||
8556                                      zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
8557                                         break;
8558                                 }
8559                                 zend_hash_move_forward(fe_ht);
8560                         }
8561                 }
8562                 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
8563                 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
8564         } else {
8565                 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
8566                 is_empty = 1;
8567         }
8568 
8569         if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
8570 
8571         }
8572         if (is_empty) {
8573                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
8574         } else {
8575                 CHECK_EXCEPTION();
8576                 ZEND_VM_NEXT_OPCODE();
8577         }
8578 }
8579 
8580 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8581 {
8582 #if 0 || (IS_TMP_VAR != IS_UNUSED)
8583         USE_OPLINE
8584 
8585         SAVE_OPLINE();
8586         if (IS_TMP_VAR != IS_UNUSED) {
8587                 zend_free_op free_op1;
8588                 zval *ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8589 
8590                 if (Z_TYPE_P(ptr) == IS_LONG) {
8591                         EG(exit_status) = Z_LVAL_P(ptr);
8592                 } else {
8593                         zend_print_variable(ptr);
8594                 }
8595                 zval_dtor(free_op1.var);
8596         }
8597 #endif
8598         zend_bailout();
8599         ZEND_VM_NEXT_OPCODE(); /* Never reached */
8600 }
8601 
8602 static int ZEND_FASTCALL  ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8603 {
8604         USE_OPLINE
8605         zval restored_error_reporting;
8606 
8607         SAVE_OPLINE();
8608         if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.var).tmp_var) != 0) {
8609                 Z_TYPE(restored_error_reporting) = IS_LONG;
8610                 Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.var).tmp_var);
8611                 EG(error_reporting) = Z_LVAL(restored_error_reporting);
8612                 convert_to_string(&restored_error_reporting);
8613                 if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) {
8614                         if (EXPECTED(EG(error_reporting_ini_entry)->modified &&
8615                             EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) {
8616                                 efree(EG(error_reporting_ini_entry)->value);
8617                         }
8618                         EG(error_reporting_ini_entry)->value = Z_STRVAL(restored_error_reporting);
8619                         EG(error_reporting_ini_entry)->value_length = Z_STRLEN(restored_error_reporting);
8620                 } else {
8621                         zendi_zval_dtor(restored_error_reporting);
8622                 }
8623         }
8624         if (EX(old_error_reporting) == &EX_T(opline->op1.var).tmp_var) {
8625                 EX(old_error_reporting) = NULL;
8626         }
8627         CHECK_EXCEPTION();
8628         ZEND_VM_NEXT_OPCODE();
8629 }
8630 
8631 static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8632 {
8633         USE_OPLINE
8634         zend_free_op free_op1;
8635         zval *value;
8636 
8637         SAVE_OPLINE();
8638         value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8639 
8640         if (i_zend_is_true(value)) {
8641                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
8642                 if (!1) {
8643                         zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
8644                 }
8645 
8646 #if DEBUG_ZEND>=2
8647                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
8648 #endif
8649                 ZEND_VM_JMP(opline->op2.jmp_addr);
8650         }
8651 
8652         zval_dtor(free_op1.var);
8653         CHECK_EXCEPTION();
8654         ZEND_VM_NEXT_OPCODE();
8655 }
8656 
8657 static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8658 {
8659         USE_OPLINE
8660         zend_free_op free_op1;
8661         zval *value, *ret;
8662 
8663         SAVE_OPLINE();
8664         value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8665 
8666         if (i_zend_is_true(value)) {
8667                 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
8668                         Z_ADDREF_P(value);
8669                         EX_T(opline->result.var).var.ptr = value;
8670                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8671                 } else {
8672                         ALLOC_ZVAL(ret);
8673                         INIT_PZVAL_COPY(ret, value);
8674                         EX_T(opline->result.var).var.ptr = ret;
8675                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8676                         if (!1) {
8677                                 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
8678                         }
8679                 }
8680 
8681 #if DEBUG_ZEND>=2
8682                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
8683 #endif
8684                 ZEND_VM_JMP(opline->op2.jmp_addr);
8685         }
8686 
8687         zval_dtor(free_op1.var);
8688         CHECK_EXCEPTION();
8689         ZEND_VM_NEXT_OPCODE();
8690 }
8691 
8692 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8693 {
8694         USE_OPLINE
8695         zend_free_op free_op1;
8696         zval *value;
8697 
8698         SAVE_OPLINE();
8699         value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8700 
8701         ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
8702         if (!1) {
8703                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
8704         }
8705 
8706         CHECK_EXCEPTION();
8707         ZEND_VM_NEXT_OPCODE();
8708 }
8709 
8710 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8711 {
8712         USE_OPLINE
8713         zend_free_op free_op1;
8714         zval *value, *ret;
8715 
8716         SAVE_OPLINE();
8717         value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8718 
8719         if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
8720                 Z_ADDREF_P(value);
8721                 EX_T(opline->result.var).var.ptr = value;
8722                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8723         } else {
8724                 ALLOC_ZVAL(ret);
8725                 INIT_PZVAL_COPY(ret, value);
8726                 EX_T(opline->result.var).var.ptr = ret;
8727                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
8728                 if (!1) {
8729                         zval_copy_ctor(EX_T(opline->result.var).var.ptr);
8730                 }
8731         }
8732 
8733         CHECK_EXCEPTION();
8734         ZEND_VM_NEXT_OPCODE();
8735 }
8736 
8737 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8738 {
8739         USE_OPLINE
8740         zend_free_op free_op1;
8741         zval *expr;
8742         zend_bool result;
8743 
8744         SAVE_OPLINE();
8745         expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
8746 
8747         if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
8748                 result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
8749         } else {
8750                 result = 0;
8751         }
8752         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
8753         zval_dtor(free_op1.var);
8754         CHECK_EXCEPTION();
8755         ZEND_VM_NEXT_OPCODE();
8756 }
8757 
8758 static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8759 {
8760         USE_OPLINE
8761         zend_free_op free_op1;
8762 
8763         SAVE_OPLINE();
8764         fast_add_function(&EX_T(opline->result.var).tmp_var,
8765                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8766                 opline->op2.zv TSRMLS_CC);
8767         zval_dtor(free_op1.var);
8768 
8769         CHECK_EXCEPTION();
8770         ZEND_VM_NEXT_OPCODE();
8771 }
8772 
8773 static int ZEND_FASTCALL  ZEND_SUB_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8774 {
8775         USE_OPLINE
8776         zend_free_op free_op1;
8777 
8778         SAVE_OPLINE();
8779         fast_sub_function(&EX_T(opline->result.var).tmp_var,
8780                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8781                 opline->op2.zv TSRMLS_CC);
8782         zval_dtor(free_op1.var);
8783 
8784         CHECK_EXCEPTION();
8785         ZEND_VM_NEXT_OPCODE();
8786 }
8787 
8788 static int ZEND_FASTCALL  ZEND_MUL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8789 {
8790         USE_OPLINE
8791         zend_free_op free_op1;
8792 
8793         SAVE_OPLINE();
8794         fast_mul_function(&EX_T(opline->result.var).tmp_var,
8795                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8796                 opline->op2.zv TSRMLS_CC);
8797         zval_dtor(free_op1.var);
8798 
8799         CHECK_EXCEPTION();
8800         ZEND_VM_NEXT_OPCODE();
8801 }
8802 
8803 static int ZEND_FASTCALL  ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8804 {
8805         USE_OPLINE
8806         zend_free_op free_op1;
8807 
8808         SAVE_OPLINE();
8809         fast_div_function(&EX_T(opline->result.var).tmp_var,
8810                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8811                 opline->op2.zv TSRMLS_CC);
8812         zval_dtor(free_op1.var);
8813 
8814         CHECK_EXCEPTION();
8815         ZEND_VM_NEXT_OPCODE();
8816 }
8817 
8818 static int ZEND_FASTCALL  ZEND_MOD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8819 {
8820         USE_OPLINE
8821         zend_free_op free_op1;
8822 
8823         SAVE_OPLINE();
8824         fast_mod_function(&EX_T(opline->result.var).tmp_var,
8825                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8826                 opline->op2.zv TSRMLS_CC);
8827         zval_dtor(free_op1.var);
8828 
8829         CHECK_EXCEPTION();
8830         ZEND_VM_NEXT_OPCODE();
8831 }
8832 
8833 static int ZEND_FASTCALL  ZEND_SL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8834 {
8835         USE_OPLINE
8836         zend_free_op free_op1;
8837 
8838         SAVE_OPLINE();
8839         shift_left_function(&EX_T(opline->result.var).tmp_var,
8840                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8841                 opline->op2.zv TSRMLS_CC);
8842         zval_dtor(free_op1.var);
8843 
8844         CHECK_EXCEPTION();
8845         ZEND_VM_NEXT_OPCODE();
8846 }
8847 
8848 static int ZEND_FASTCALL  ZEND_SR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8849 {
8850         USE_OPLINE
8851         zend_free_op free_op1;
8852 
8853         SAVE_OPLINE();
8854         shift_right_function(&EX_T(opline->result.var).tmp_var,
8855                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8856                 opline->op2.zv TSRMLS_CC);
8857         zval_dtor(free_op1.var);
8858 
8859         CHECK_EXCEPTION();
8860         ZEND_VM_NEXT_OPCODE();
8861 }
8862 
8863 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8864 {
8865         USE_OPLINE
8866         zend_free_op free_op1;
8867 
8868         SAVE_OPLINE();
8869         concat_function(&EX_T(opline->result.var).tmp_var,
8870                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8871                 opline->op2.zv TSRMLS_CC);
8872         zval_dtor(free_op1.var);
8873 
8874         CHECK_EXCEPTION();
8875         ZEND_VM_NEXT_OPCODE();
8876 }
8877 
8878 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8879 {
8880         USE_OPLINE
8881         zend_free_op free_op1;
8882 
8883         SAVE_OPLINE();
8884         is_identical_function(&EX_T(opline->result.var).tmp_var,
8885                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8886                 opline->op2.zv TSRMLS_CC);
8887         zval_dtor(free_op1.var);
8888 
8889         CHECK_EXCEPTION();
8890         ZEND_VM_NEXT_OPCODE();
8891 }
8892 
8893 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8894 {
8895         USE_OPLINE
8896         zend_free_op free_op1;
8897         zval *result = &EX_T(opline->result.var).tmp_var;
8898 
8899         SAVE_OPLINE();
8900         is_identical_function(result,
8901                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8902                 opline->op2.zv TSRMLS_CC);
8903         Z_LVAL_P(result) = !Z_LVAL_P(result);
8904         zval_dtor(free_op1.var);
8905 
8906         CHECK_EXCEPTION();
8907         ZEND_VM_NEXT_OPCODE();
8908 }
8909 
8910 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8911 {
8912         USE_OPLINE
8913         zend_free_op free_op1;
8914         zval *result = &EX_T(opline->result.var).tmp_var;
8915 
8916         SAVE_OPLINE();
8917         ZVAL_BOOL(result, fast_equal_function(result,
8918                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8919                 opline->op2.zv TSRMLS_CC));
8920         zval_dtor(free_op1.var);
8921 
8922         CHECK_EXCEPTION();
8923         ZEND_VM_NEXT_OPCODE();
8924 }
8925 
8926 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8927 {
8928         USE_OPLINE
8929         zend_free_op free_op1;
8930         zval *result = &EX_T(opline->result.var).tmp_var;
8931 
8932         SAVE_OPLINE();
8933         ZVAL_BOOL(result, fast_not_equal_function(result,
8934                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8935                 opline->op2.zv TSRMLS_CC));
8936         zval_dtor(free_op1.var);
8937 
8938         CHECK_EXCEPTION();
8939         ZEND_VM_NEXT_OPCODE();
8940 }
8941 
8942 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8943 {
8944         USE_OPLINE
8945         zend_free_op free_op1;
8946         zval *result = &EX_T(opline->result.var).tmp_var;
8947 
8948         SAVE_OPLINE();
8949         ZVAL_BOOL(result, fast_is_smaller_function(result,
8950                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8951                 opline->op2.zv TSRMLS_CC));
8952         zval_dtor(free_op1.var);
8953 
8954         CHECK_EXCEPTION();
8955         ZEND_VM_NEXT_OPCODE();
8956 }
8957 
8958 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8959 {
8960         USE_OPLINE
8961         zend_free_op free_op1;
8962         zval *result = &EX_T(opline->result.var).tmp_var;
8963 
8964         SAVE_OPLINE();
8965         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
8966                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8967                 opline->op2.zv TSRMLS_CC));
8968         zval_dtor(free_op1.var);
8969 
8970         CHECK_EXCEPTION();
8971         ZEND_VM_NEXT_OPCODE();
8972 }
8973 
8974 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8975 {
8976         USE_OPLINE
8977         zend_free_op free_op1;
8978 
8979         SAVE_OPLINE();
8980         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
8981                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8982                 opline->op2.zv TSRMLS_CC);
8983         zval_dtor(free_op1.var);
8984 
8985         CHECK_EXCEPTION();
8986         ZEND_VM_NEXT_OPCODE();
8987 }
8988 
8989 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8990 {
8991         USE_OPLINE
8992         zend_free_op free_op1;
8993 
8994         SAVE_OPLINE();
8995         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
8996                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
8997                 opline->op2.zv TSRMLS_CC);
8998         zval_dtor(free_op1.var);
8999 
9000         CHECK_EXCEPTION();
9001         ZEND_VM_NEXT_OPCODE();
9002 }
9003 
9004 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9005 {
9006         USE_OPLINE
9007         zend_free_op free_op1;
9008 
9009         SAVE_OPLINE();
9010         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
9011                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9012                 opline->op2.zv TSRMLS_CC);
9013         zval_dtor(free_op1.var);
9014 
9015         CHECK_EXCEPTION();
9016         ZEND_VM_NEXT_OPCODE();
9017 }
9018 
9019 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9020 {
9021         USE_OPLINE
9022         zend_free_op free_op1;
9023 
9024         SAVE_OPLINE();
9025         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
9026                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9027                 opline->op2.zv TSRMLS_CC);
9028         zval_dtor(free_op1.var);
9029 
9030         CHECK_EXCEPTION();
9031         ZEND_VM_NEXT_OPCODE();
9032 }
9033 
9034 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
9035 {
9036         USE_OPLINE
9037         zend_free_op free_op1;
9038         zval *varname;
9039         zval **retval;
9040         zval tmp_varname;
9041         HashTable *target_symbol_table;
9042         ulong hash_value;
9043 
9044         SAVE_OPLINE();
9045         varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9046 
9047         if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
9048                 ZVAL_COPY_VALUE(&tmp_varname, varname);
9049                 zval_copy_ctor(&tmp_varname);
9050                 Z_SET_REFCOUNT(tmp_varname, 1);
9051                 Z_UNSET_ISREF(tmp_varname);
9052                 convert_to_string(&tmp_varname);
9053                 varname = &tmp_varname;
9054         }
9055 
9056         if (IS_CONST != IS_UNUSED) {
9057                 zend_class_entry *ce;
9058 
9059                 if (IS_CONST == IS_CONST) {
9060                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
9061                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
9062                         } else {
9063                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
9064                                 if (UNEXPECTED(ce == NULL)) {
9065                                         if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
9066                                                 zval_dtor(&tmp_varname);
9067                                         }
9068                                         zval_dtor(free_op1.var);
9069                                         CHECK_EXCEPTION();
9070                                         ZEND_VM_NEXT_OPCODE();
9071                                 }
9072                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
9073                         }
9074                 } else {
9075                         ce = EX_T(opline->op2.var).class_entry;
9076                 }
9077                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
9078                 zval_dtor(free_op1.var);
9079         } else {
9080                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
9081 /*
9082                 if (!target_symbol_table) {
9083                         CHECK_EXCEPTION();
9084                         ZEND_VM_NEXT_OPCODE();
9085                 }
9086 */
9087                 if (IS_TMP_VAR == IS_CONST) {
9088                         hash_value = Z_HASH_P(varname);
9089                 } else {
9090                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
9091                 }
9092 
9093                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
9094                         switch (type) {
9095                                 case BP_VAR_R:
9096                                 case BP_VAR_UNSET:
9097                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
9098                                         /* break missing intentionally */
9099                                 case BP_VAR_IS:
9100                                         retval = &EG(uninitialized_zval_ptr);
9101                                         break;
9102                                 case BP_VAR_RW:
9103                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
9104                                         /* break missing intentionally */
9105                                 case BP_VAR_W:
9106                                         Z_ADDREF_P(&EG(uninitialized_zval));
9107                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
9108                                         break;
9109                                 EMPTY_SWITCH_DEFAULT_CASE()
9110                         }
9111                 }
9112                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
9113                         case ZEND_FETCH_GLOBAL:
9114                                 if (IS_TMP_VAR != IS_TMP_VAR) {
9115                                         zval_dtor(free_op1.var);
9116                                 }
9117                                 break;
9118                         case ZEND_FETCH_LOCAL:
9119                                 zval_dtor(free_op1.var);
9120                                 break;
9121                         case ZEND_FETCH_STATIC:
9122                                 zval_update_constant(retval, 1 TSRMLS_CC);
9123                                 break;
9124                         case ZEND_FETCH_GLOBAL_LOCK:
9125                                 if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
9126                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
9127                                 }
9128                                 break;
9129                 }
9130         }
9131 
9132 
9133         if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
9134                 zval_dtor(&tmp_varname);
9135         }
9136         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
9137                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
9138         }
9139         PZVAL_LOCK(*retval);
9140         switch (type) {
9141                 case BP_VAR_R:
9142                 case BP_VAR_IS:
9143                         EX_T(opline->result.var).var.ptr = *retval;
9144                         break;
9145                 case BP_VAR_UNSET: {
9146                         zend_free_op free_res;
9147 
9148                         PZVAL_UNLOCK(*retval, &free_res);
9149                         if (retval != &EG(uninitialized_zval_ptr)) {
9150                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
9151                         }
9152                         PZVAL_LOCK(*retval);
9153                         FREE_OP_VAR_PTR(free_res);
9154                 }
9155                 /* break missing intentionally */
9156                 default:
9157                         EX_T(opline->result.var).var.ptr_ptr = retval;
9158                         break;
9159         }
9160         CHECK_EXCEPTION();
9161         ZEND_VM_NEXT_OPCODE();
9162 }
9163 
9164 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9165 {
9166         return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9167 }
9168 
9169 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9170 {
9171         return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9172 }
9173 
9174 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9175 {
9176         return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9177 }
9178 
9179 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9180 {
9181         USE_OPLINE
9182 
9183         return zend_fetch_var_address_helper_SPEC_TMP_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9184 }
9185 
9186 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9187 {
9188         return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9189 }
9190 
9191 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9192 {
9193         return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9194 }
9195 
9196 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9197 {
9198         USE_OPLINE
9199         zend_free_op free_op1;
9200         zval *container;
9201 
9202         SAVE_OPLINE();
9203         container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9204         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
9205 
9206         if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
9207                 zval_dtor(free_op1.var);
9208         }
9209         CHECK_EXCEPTION();
9210         ZEND_VM_NEXT_OPCODE();
9211 }
9212 
9213 static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9214 {
9215         USE_OPLINE
9216         zend_free_op free_op1;
9217         zval *container;
9218 
9219         SAVE_OPLINE();
9220         container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9221 
9222         if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
9223                 PZVAL_LOCK(&EG(uninitialized_zval));
9224                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
9225         } else {
9226 
9227                 zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
9228 
9229                 PZVAL_LOCK(value);
9230                 EX_T(opline->result.var).var.ptr = value;
9231 
9232         }
9233         CHECK_EXCEPTION();
9234         ZEND_VM_NEXT_OPCODE();
9235 }
9236 
9237 static int ZEND_FASTCALL  ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9238 {
9239         USE_OPLINE
9240         zval *str = &EX_T(opline->result.var).tmp_var;
9241 
9242         SAVE_OPLINE();
9243 
9244         if (IS_TMP_VAR == IS_UNUSED) {
9245                 /* Initialize for erealloc in add_char_to_string */
9246                 Z_STRVAL_P(str) = NULL;
9247                 Z_STRLEN_P(str) = 0;
9248                 Z_TYPE_P(str) = IS_STRING;
9249 
9250                 INIT_PZVAL(str);
9251         }
9252 
9253         add_char_to_string(str, str, opline->op2.zv);
9254 
9255         /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
9256         /*CHECK_EXCEPTION();*/
9257         ZEND_VM_NEXT_OPCODE();
9258 }
9259 
9260 static int ZEND_FASTCALL  ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9261 {
9262         USE_OPLINE
9263         zval *str = &EX_T(opline->result.var).tmp_var;
9264 
9265         SAVE_OPLINE();
9266 
9267         if (IS_TMP_VAR == IS_UNUSED) {
9268                 /* Initialize for erealloc in add_string_to_string */
9269                 Z_STRVAL_P(str) = NULL;
9270                 Z_STRLEN_P(str) = 0;
9271                 Z_TYPE_P(str) = IS_STRING;
9272 
9273                 INIT_PZVAL(str);
9274         }
9275 
9276         add_string_to_string(str, str, opline->op2.zv);
9277 
9278         /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
9279         /*CHECK_EXCEPTION();*/
9280         ZEND_VM_NEXT_OPCODE();
9281 }
9282 
9283 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9284 {
9285         USE_OPLINE
9286         zval *function_name;
9287         char *function_name_strval;
9288         int function_name_strlen;
9289         zend_free_op free_op1;
9290         call_slot *call = EX(call_slots) + opline->result.num;
9291 
9292         SAVE_OPLINE();
9293 
9294         function_name = opline->op2.zv;
9295 
9296         if (IS_CONST != IS_CONST &&
9297             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9298                 if (UNEXPECTED(EG(exception) != NULL)) {
9299                         HANDLE_EXCEPTION();
9300                 }
9301                 zend_error_noreturn(E_ERROR, "Method name must be a string");
9302         }
9303 
9304         function_name_strval = Z_STRVAL_P(function_name);
9305         function_name_strlen = Z_STRLEN_P(function_name);
9306 
9307         call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9308 
9309         if (EXPECTED(call->object != NULL) &&
9310             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
9311                 call->called_scope = Z_OBJCE_P(call->object);
9312 
9313                 if (IS_CONST != IS_CONST ||
9314                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
9315                     zval *object = call->object;
9316 
9317                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
9318                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
9319                         }
9320 
9321                         /* First, locate the function. */
9322                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
9323                         if (UNEXPECTED(call->fbc == NULL)) {
9324                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
9325                         }
9326                         if (IS_CONST == IS_CONST &&
9327                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
9328                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
9329                             EXPECTED(call->object == object)) {
9330                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
9331                         }
9332                 }
9333         } else {
9334                 if (UNEXPECTED(EG(exception) != NULL)) {
9335 
9336                         HANDLE_EXCEPTION();
9337                 }
9338                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
9339         }
9340 
9341         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
9342                 call->object = NULL;
9343         } else {
9344                 if (!PZVAL_IS_REF(call->object)) {
9345                         Z_ADDREF_P(call->object); /* For $this pointer */
9346                 } else {
9347                         zval *this_ptr;
9348                         ALLOC_ZVAL(this_ptr);
9349                         INIT_PZVAL_COPY(this_ptr, call->object);
9350                         zval_copy_ctor(this_ptr);
9351                         call->object = this_ptr;
9352                 }
9353         }
9354 
9355         call->num_additional_args = 0;
9356         call->is_ctor_call = 0;
9357         EX(call) = call;
9358 
9359 
9360         CHECK_EXCEPTION();
9361         ZEND_VM_NEXT_OPCODE();
9362 }
9363 
9364 static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9365 {
9366         USE_OPLINE
9367         zend_free_op free_op1;
9368 
9369         SAVE_OPLINE();
9370         is_equal_function(&EX_T(opline->result.var).tmp_var,
9371                                  _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9372                                  opline->op2.zv TSRMLS_CC);
9373 
9374         CHECK_EXCEPTION();
9375         ZEND_VM_NEXT_OPCODE();
9376 }
9377 
9378 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9379 {
9380         USE_OPLINE
9381         zend_free_op free_op1;
9382         zval *expr_ptr;
9383 
9384         SAVE_OPLINE();
9385         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
9386                 zval **expr_ptr_ptr = NULL;
9387 
9388                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
9389                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
9390                 }
9391                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
9392                 expr_ptr = *expr_ptr_ptr;
9393                 Z_ADDREF_P(expr_ptr);
9394         } else {
9395                 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9396                 if (1) { /* temporary variable */
9397                         zval *new_expr;
9398 
9399                         ALLOC_ZVAL(new_expr);
9400                         INIT_PZVAL_COPY(new_expr, expr_ptr);
9401                         expr_ptr = new_expr;
9402                 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
9403                         zval *new_expr;
9404 
9405                         ALLOC_ZVAL(new_expr);
9406                         INIT_PZVAL_COPY(new_expr, expr_ptr);
9407                         expr_ptr = new_expr;
9408                         zendi_zval_copy_ctor(*expr_ptr);
9409 
9410                 } else if (IS_TMP_VAR == IS_CV) {
9411                         Z_ADDREF_P(expr_ptr);
9412                 }
9413         }
9414 
9415         if (IS_CONST != IS_UNUSED) {
9416 
9417                 zval *offset = opline->op2.zv;
9418                 ulong hval;
9419 
9420                 switch (Z_TYPE_P(offset)) {
9421                         case IS_DOUBLE:
9422                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
9423                                 goto num_index;
9424                         case IS_LONG:
9425                         case IS_BOOL:
9426                                 hval = Z_LVAL_P(offset);
9427 num_index:
9428                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
9429                                 break;
9430                         case IS_STRING:
9431                                 if (IS_CONST == IS_CONST) {
9432                                         hval = Z_HASH_P(offset);
9433                                 } else {
9434                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
9435                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
9436                                 }
9437                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
9438                                 break;
9439                         case IS_NULL:
9440                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
9441                                 break;
9442                         default:
9443                                 zend_error(E_WARNING, "Illegal offset type");
9444                                 zval_ptr_dtor(&expr_ptr);
9445                                 /* do nothing */
9446                                 break;
9447                 }
9448 
9449         } else {
9450                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
9451         }
9452         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
9453 
9454         }
9455         CHECK_EXCEPTION();
9456         ZEND_VM_NEXT_OPCODE();
9457 }
9458 
9459 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9460 {
9461         USE_OPLINE
9462 
9463         array_init(&EX_T(opline->result.var).tmp_var);
9464         if (IS_TMP_VAR == IS_UNUSED) {
9465                 ZEND_VM_NEXT_OPCODE();
9466 #if 0 || IS_TMP_VAR != IS_UNUSED
9467         } else {
9468                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
9469 #endif
9470         }
9471 }
9472 
9473 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9474 {
9475         USE_OPLINE
9476         zval tmp, *varname;
9477         HashTable *target_symbol_table;
9478         zend_free_op free_op1;
9479 
9480         SAVE_OPLINE();
9481         if (IS_TMP_VAR == IS_CV &&
9482             IS_CONST == IS_UNUSED &&
9483             (opline->extended_value & ZEND_QUICK_SET)) {
9484                 if (EG(active_symbol_table)) {
9485                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
9486 
9487                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
9488                         EX_CV(opline->op1.var) = NULL;
9489                 } else if (EX_CV(opline->op1.var)) {
9490                         zval_ptr_dtor(EX_CV(opline->op1.var));
9491                         EX_CV(opline->op1.var) = NULL;
9492                 }
9493                 CHECK_EXCEPTION();
9494                 ZEND_VM_NEXT_OPCODE();
9495         }
9496 
9497         varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9498 
9499         if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
9500                 ZVAL_COPY_VALUE(&tmp, varname);
9501                 zval_copy_ctor(&tmp);
9502                 convert_to_string(&tmp);
9503                 varname = &tmp;
9504         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
9505                 Z_ADDREF_P(varname);
9506         }
9507 
9508         if (IS_CONST != IS_UNUSED) {
9509                 zend_class_entry *ce;
9510 
9511                 if (IS_CONST == IS_CONST) {
9512                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
9513                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
9514                         } else {
9515                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
9516                                 if (UNEXPECTED(EG(exception) != NULL)) {
9517                                         if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
9518                                                 zval_dtor(&tmp);
9519                                         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
9520                                                 zval_ptr_dtor(&varname);
9521                                         }
9522                                         zval_dtor(free_op1.var);
9523                                         HANDLE_EXCEPTION();
9524                                 }
9525                                 if (UNEXPECTED(ce == NULL)) {
9526                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
9527                                 }
9528                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
9529                         }
9530                 } else {
9531                         ce = EX_T(opline->op2.var).class_entry;
9532                 }
9533                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
9534         } else {
9535                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
9536 
9537                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
9538                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
9539         }
9540 
9541         if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
9542                 zval_dtor(&tmp);
9543         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
9544                 zval_ptr_dtor(&varname);
9545         }
9546         zval_dtor(free_op1.var);
9547         CHECK_EXCEPTION();
9548         ZEND_VM_NEXT_OPCODE();
9549 }
9550 
9551 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9552 {
9553         USE_OPLINE
9554         zval **value;
9555         zend_bool isset = 1;
9556 
9557         SAVE_OPLINE();
9558         if (IS_TMP_VAR == IS_CV &&
9559             IS_CONST == IS_UNUSED &&
9560             (opline->extended_value & ZEND_QUICK_SET)) {
9561                 if (EX_CV(opline->op1.var)) {
9562                         value = EX_CV(opline->op1.var);
9563                 } else if (EG(active_symbol_table)) {
9564                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
9565 
9566                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
9567                                 isset = 0;
9568                         }
9569                 } else {
9570                         isset = 0;
9571                 }
9572         } else {
9573                 HashTable *target_symbol_table;
9574                 zend_free_op free_op1;
9575                 zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9576 
9577                 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
9578                         ZVAL_COPY_VALUE(&tmp, varname);
9579                         zval_copy_ctor(&tmp);
9580                         convert_to_string(&tmp);
9581                         varname = &tmp;
9582                 }
9583 
9584                 if (IS_CONST != IS_UNUSED) {
9585                         zend_class_entry *ce;
9586 
9587                         if (IS_CONST == IS_CONST) {
9588                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
9589                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
9590                                 } else {
9591                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
9592                                         if (UNEXPECTED(ce == NULL)) {
9593                                                 CHECK_EXCEPTION();
9594                                                 ZEND_VM_NEXT_OPCODE();
9595                                         }
9596                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
9597                                 }
9598                         } else {
9599                                 ce = EX_T(opline->op2.var).class_entry;
9600                         }
9601                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
9602                         if (!value) {
9603                                 isset = 0;
9604                         }
9605                 } else {
9606                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
9607                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
9608                                 isset = 0;
9609                         }
9610                 }
9611 
9612                 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
9613                         zval_dtor(&tmp);
9614                 }
9615                 zval_dtor(free_op1.var);
9616         }
9617 
9618         if (opline->extended_value & ZEND_ISSET) {
9619                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
9620                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
9621                 } else {
9622                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
9623                 }
9624         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
9625                 if (!isset || !i_zend_is_true(*value)) {
9626                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
9627                 } else {
9628                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
9629                 }
9630         }
9631 
9632         CHECK_EXCEPTION();
9633         ZEND_VM_NEXT_OPCODE();
9634 }
9635 
9636 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9637 {
9638         USE_OPLINE
9639 
9640         /* The generator object is stored in return_value_ptr_ptr */
9641         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
9642 
9643         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
9644                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
9645         }
9646 
9647         /* Destroy the previously yielded value */
9648         if (generator->value) {
9649                 zval_ptr_dtor(&generator->value);
9650         }
9651 
9652         /* Destroy the previously yielded key */
9653         if (generator->key) {
9654                 zval_ptr_dtor(&generator->key);
9655         }
9656 
9657         /* Set the new yielded value */
9658         if (IS_TMP_VAR != IS_UNUSED) {
9659                 zend_free_op free_op1;
9660 
9661                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
9662                         /* Constants and temporary variables aren't yieldable by reference,
9663                          * but we still allow them with a notice. */
9664                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
9665                                 zval *value, *copy;
9666 
9667                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
9668 
9669                                 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9670                                 ALLOC_ZVAL(copy);
9671                                 INIT_PZVAL_COPY(copy, value);
9672 
9673                                 /* Temporary variables don't need ctor copying */
9674                                 if (!1) {
9675                                         zval_copy_ctor(copy);
9676                                 }
9677 
9678                                 generator->value = copy;
9679                         } else {
9680                                 zval **value_ptr = NULL;
9681 
9682                                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
9683                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
9684                                 }
9685 
9686                                 /* If a function call result is yielded and the function did
9687                                  * not return by reference we throw a notice. */
9688                                 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
9689                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
9690                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
9691                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
9692                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
9693 
9694                                         Z_ADDREF_PP(value_ptr);
9695                                         generator->value = *value_ptr;
9696                                 } else {
9697                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
9698                                         Z_ADDREF_PP(value_ptr);
9699                                         generator->value = *value_ptr;
9700                                 }
9701 
9702                         }
9703                 } else {
9704                         zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
9705 
9706                         /* Consts, temporary variables and references need copying */
9707                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
9708                                 || PZVAL_IS_REF(value)
9709                         ) {
9710                                 zval *copy;
9711 
9712                                 ALLOC_ZVAL(copy);
9713                                 INIT_PZVAL_COPY(copy, value);
9714 
9715                                 /* Temporary variables don't need ctor copying */
9716                                 if (!1) {
9717                                         zval_copy_ctor(copy);
9718                                 }
9719 
9720                                 generator->value = copy;
9721 
9722                         } else {
9723                                 if (IS_TMP_VAR == IS_CV) {
9724                                         Z_ADDREF_P(value);
9725                                 }
9726                                 generator->value = value;
9727                         }
9728                 }
9729         } else {
9730                 /* If no value was specified yield null */
9731                 Z_ADDREF(EG(uninitialized_zval));
9732                 generator->value = &EG(uninitialized_zval);
9733         }
9734 
9735         /* Set the new yielded key */
9736         if (IS_CONST != IS_UNUSED) {
9737 
9738                 zval *key = opline->op2.zv;
9739 
9740                 /* Consts, temporary variables and references need copying */
9741                 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
9742                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
9743                 ) {
9744                         zval *copy;
9745 
9746                         ALLOC_ZVAL(copy);
9747                         INIT_PZVAL_COPY(copy, key);
9748 
9749                         /* Temporary variables don't need ctor copying */
9750                         if (!0) {
9751                                 zval_copy_ctor(copy);
9752                         }
9753 
9754                         generator->key = copy;
9755                 } else {
9756                         Z_ADDREF_P(key);
9757                         generator->key = key;
9758                 }
9759 
9760                 if (Z_TYPE_P(generator->key) == IS_LONG
9761                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
9762                 ) {
9763                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
9764                 }
9765 
9766         } else {
9767                 /* If no key was specified we use auto-increment keys */
9768                 generator->largest_used_integer_key++;
9769 
9770                 ALLOC_INIT_ZVAL(generator->key);
9771                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
9772         }
9773 
9774         if (RETURN_VALUE_USED(opline)) {
9775                 /* If the return value of yield is used set the send
9776                  * target and initialize it to NULL */
9777                 generator->send_target = &EX_T(opline->result.var).var.ptr;
9778                 Z_ADDREF(EG(uninitialized_zval));
9779                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
9780         } else {
9781                 generator->send_target = NULL;
9782         }
9783 
9784         /* We increment to the next op, so we are at the correct position when the
9785          * generator is resumed. */
9786         ZEND_VM_INC_OPCODE();
9787 
9788         /* The GOTO VM uses a local opline variable. We need to set the opline
9789          * variable in execute_data so we don't resume at an old position. */
9790         SAVE_OPLINE();
9791 
9792         ZEND_VM_RETURN();
9793 }
9794 
9795 static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9796 {
9797         USE_OPLINE
9798         zend_free_op free_op1;
9799 
9800         SAVE_OPLINE();
9801         pow_function(&EX_T(opline->result.var).tmp_var,
9802                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9803                 opline->op2.zv TSRMLS_CC);
9804         zval_dtor(free_op1.var);
9805 
9806         CHECK_EXCEPTION();
9807         ZEND_VM_NEXT_OPCODE();
9808 }
9809 
9810 static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9811 {
9812         USE_OPLINE
9813         zend_free_op free_op1, free_op2;
9814 
9815         SAVE_OPLINE();
9816         fast_add_function(&EX_T(opline->result.var).tmp_var,
9817                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9818                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9819         zval_dtor(free_op1.var);
9820         zval_dtor(free_op2.var);
9821         CHECK_EXCEPTION();
9822         ZEND_VM_NEXT_OPCODE();
9823 }
9824 
9825 static int ZEND_FASTCALL  ZEND_SUB_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9826 {
9827         USE_OPLINE
9828         zend_free_op free_op1, free_op2;
9829 
9830         SAVE_OPLINE();
9831         fast_sub_function(&EX_T(opline->result.var).tmp_var,
9832                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9833                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9834         zval_dtor(free_op1.var);
9835         zval_dtor(free_op2.var);
9836         CHECK_EXCEPTION();
9837         ZEND_VM_NEXT_OPCODE();
9838 }
9839 
9840 static int ZEND_FASTCALL  ZEND_MUL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9841 {
9842         USE_OPLINE
9843         zend_free_op free_op1, free_op2;
9844 
9845         SAVE_OPLINE();
9846         fast_mul_function(&EX_T(opline->result.var).tmp_var,
9847                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9848                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9849         zval_dtor(free_op1.var);
9850         zval_dtor(free_op2.var);
9851         CHECK_EXCEPTION();
9852         ZEND_VM_NEXT_OPCODE();
9853 }
9854 
9855 static int ZEND_FASTCALL  ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9856 {
9857         USE_OPLINE
9858         zend_free_op free_op1, free_op2;
9859 
9860         SAVE_OPLINE();
9861         fast_div_function(&EX_T(opline->result.var).tmp_var,
9862                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9863                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9864         zval_dtor(free_op1.var);
9865         zval_dtor(free_op2.var);
9866         CHECK_EXCEPTION();
9867         ZEND_VM_NEXT_OPCODE();
9868 }
9869 
9870 static int ZEND_FASTCALL  ZEND_MOD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9871 {
9872         USE_OPLINE
9873         zend_free_op free_op1, free_op2;
9874 
9875         SAVE_OPLINE();
9876         fast_mod_function(&EX_T(opline->result.var).tmp_var,
9877                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9878                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9879         zval_dtor(free_op1.var);
9880         zval_dtor(free_op2.var);
9881         CHECK_EXCEPTION();
9882         ZEND_VM_NEXT_OPCODE();
9883 }
9884 
9885 static int ZEND_FASTCALL  ZEND_SL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9886 {
9887         USE_OPLINE
9888         zend_free_op free_op1, free_op2;
9889 
9890         SAVE_OPLINE();
9891         shift_left_function(&EX_T(opline->result.var).tmp_var,
9892                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9893                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9894         zval_dtor(free_op1.var);
9895         zval_dtor(free_op2.var);
9896         CHECK_EXCEPTION();
9897         ZEND_VM_NEXT_OPCODE();
9898 }
9899 
9900 static int ZEND_FASTCALL  ZEND_SR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9901 {
9902         USE_OPLINE
9903         zend_free_op free_op1, free_op2;
9904 
9905         SAVE_OPLINE();
9906         shift_right_function(&EX_T(opline->result.var).tmp_var,
9907                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9908                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9909         zval_dtor(free_op1.var);
9910         zval_dtor(free_op2.var);
9911         CHECK_EXCEPTION();
9912         ZEND_VM_NEXT_OPCODE();
9913 }
9914 
9915 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9916 {
9917         USE_OPLINE
9918         zend_free_op free_op1, free_op2;
9919 
9920         SAVE_OPLINE();
9921         concat_function(&EX_T(opline->result.var).tmp_var,
9922                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9923                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9924         zval_dtor(free_op1.var);
9925         zval_dtor(free_op2.var);
9926         CHECK_EXCEPTION();
9927         ZEND_VM_NEXT_OPCODE();
9928 }
9929 
9930 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9931 {
9932         USE_OPLINE
9933         zend_free_op free_op1, free_op2;
9934 
9935         SAVE_OPLINE();
9936         is_identical_function(&EX_T(opline->result.var).tmp_var,
9937                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9938                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9939         zval_dtor(free_op1.var);
9940         zval_dtor(free_op2.var);
9941         CHECK_EXCEPTION();
9942         ZEND_VM_NEXT_OPCODE();
9943 }
9944 
9945 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9946 {
9947         USE_OPLINE
9948         zend_free_op free_op1, free_op2;
9949         zval *result = &EX_T(opline->result.var).tmp_var;
9950 
9951         SAVE_OPLINE();
9952         is_identical_function(result,
9953                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9954                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
9955         Z_LVAL_P(result) = !Z_LVAL_P(result);
9956         zval_dtor(free_op1.var);
9957         zval_dtor(free_op2.var);
9958         CHECK_EXCEPTION();
9959         ZEND_VM_NEXT_OPCODE();
9960 }
9961 
9962 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9963 {
9964         USE_OPLINE
9965         zend_free_op free_op1, free_op2;
9966         zval *result = &EX_T(opline->result.var).tmp_var;
9967 
9968         SAVE_OPLINE();
9969         ZVAL_BOOL(result, fast_equal_function(result,
9970                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9971                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
9972         zval_dtor(free_op1.var);
9973         zval_dtor(free_op2.var);
9974         CHECK_EXCEPTION();
9975         ZEND_VM_NEXT_OPCODE();
9976 }
9977 
9978 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9979 {
9980         USE_OPLINE
9981         zend_free_op free_op1, free_op2;
9982         zval *result = &EX_T(opline->result.var).tmp_var;
9983 
9984         SAVE_OPLINE();
9985         ZVAL_BOOL(result, fast_not_equal_function(result,
9986                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
9987                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
9988         zval_dtor(free_op1.var);
9989         zval_dtor(free_op2.var);
9990         CHECK_EXCEPTION();
9991         ZEND_VM_NEXT_OPCODE();
9992 }
9993 
9994 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9995 {
9996         USE_OPLINE
9997         zend_free_op free_op1, free_op2;
9998         zval *result = &EX_T(opline->result.var).tmp_var;
9999 
10000         SAVE_OPLINE();
10001         ZVAL_BOOL(result, fast_is_smaller_function(result,
10002                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10003                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10004         zval_dtor(free_op1.var);
10005         zval_dtor(free_op2.var);
10006         CHECK_EXCEPTION();
10007         ZEND_VM_NEXT_OPCODE();
10008 }
10009 
10010 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10011 {
10012         USE_OPLINE
10013         zend_free_op free_op1, free_op2;
10014         zval *result = &EX_T(opline->result.var).tmp_var;
10015 
10016         SAVE_OPLINE();
10017         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
10018                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10019                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10020         zval_dtor(free_op1.var);
10021         zval_dtor(free_op2.var);
10022         CHECK_EXCEPTION();
10023         ZEND_VM_NEXT_OPCODE();
10024 }
10025 
10026 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10027 {
10028         USE_OPLINE
10029         zend_free_op free_op1, free_op2;
10030 
10031         SAVE_OPLINE();
10032         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
10033                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10034                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10035         zval_dtor(free_op1.var);
10036         zval_dtor(free_op2.var);
10037         CHECK_EXCEPTION();
10038         ZEND_VM_NEXT_OPCODE();
10039 }
10040 
10041 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10042 {
10043         USE_OPLINE
10044         zend_free_op free_op1, free_op2;
10045 
10046         SAVE_OPLINE();
10047         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
10048                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10049                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10050         zval_dtor(free_op1.var);
10051         zval_dtor(free_op2.var);
10052         CHECK_EXCEPTION();
10053         ZEND_VM_NEXT_OPCODE();
10054 }
10055 
10056 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10057 {
10058         USE_OPLINE
10059         zend_free_op free_op1, free_op2;
10060 
10061         SAVE_OPLINE();
10062         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
10063                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10064                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10065         zval_dtor(free_op1.var);
10066         zval_dtor(free_op2.var);
10067         CHECK_EXCEPTION();
10068         ZEND_VM_NEXT_OPCODE();
10069 }
10070 
10071 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10072 {
10073         USE_OPLINE
10074         zend_free_op free_op1, free_op2;
10075 
10076         SAVE_OPLINE();
10077         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
10078                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10079                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10080         zval_dtor(free_op1.var);
10081         zval_dtor(free_op2.var);
10082         CHECK_EXCEPTION();
10083         ZEND_VM_NEXT_OPCODE();
10084 }
10085 
10086 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10087 {
10088         USE_OPLINE
10089         zend_free_op free_op1, free_op2;
10090         zval *container;
10091 
10092         SAVE_OPLINE();
10093         container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10094         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
10095         zval_dtor(free_op2.var);
10096         if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
10097                 zval_dtor(free_op1.var);
10098         }
10099         CHECK_EXCEPTION();
10100         ZEND_VM_NEXT_OPCODE();
10101 }
10102 
10103 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10104 {
10105         USE_OPLINE
10106         zend_free_op free_op2;
10107         zval *str = &EX_T(opline->result.var).tmp_var;
10108         zval *var;
10109         zval var_copy;
10110         int use_copy = 0;
10111 
10112         SAVE_OPLINE();
10113         var = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10114 
10115         if (IS_TMP_VAR == IS_UNUSED) {
10116                 /* Initialize for erealloc in add_string_to_string */
10117                 Z_STRVAL_P(str) = NULL;
10118                 Z_STRLEN_P(str) = 0;
10119                 Z_TYPE_P(str) = IS_STRING;
10120 
10121                 INIT_PZVAL(str);
10122         }
10123 
10124         if (Z_TYPE_P(var) != IS_STRING) {
10125                 zend_make_printable_zval(var, &var_copy, &use_copy);
10126 
10127                 if (use_copy) {
10128                         var = &var_copy;
10129                 }
10130         }
10131         add_string_to_string(str, str, var);
10132 
10133         if (use_copy) {
10134                 zval_dtor(var);
10135         }
10136         /* original comment, possibly problematic:
10137          * FREE_OP is missing intentionally here - we're always working on the same temporary variable
10138          * (Zeev):  I don't think it's problematic, we only use variables
10139          * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
10140          * string offsets or overloaded objects
10141          */
10142         zval_dtor(free_op2.var);
10143 
10144         CHECK_EXCEPTION();
10145         ZEND_VM_NEXT_OPCODE();
10146 }
10147 
10148 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10149 {
10150         USE_OPLINE
10151         zval *function_name;
10152         char *function_name_strval;
10153         int function_name_strlen;
10154         zend_free_op free_op1, free_op2;
10155         call_slot *call = EX(call_slots) + opline->result.num;
10156 
10157         SAVE_OPLINE();
10158 
10159         function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10160 
10161         if (IS_TMP_VAR != IS_CONST &&
10162             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10163                 if (UNEXPECTED(EG(exception) != NULL)) {
10164                         HANDLE_EXCEPTION();
10165                 }
10166                 zend_error_noreturn(E_ERROR, "Method name must be a string");
10167         }
10168 
10169         function_name_strval = Z_STRVAL_P(function_name);
10170         function_name_strlen = Z_STRLEN_P(function_name);
10171 
10172         call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10173 
10174         if (EXPECTED(call->object != NULL) &&
10175             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
10176                 call->called_scope = Z_OBJCE_P(call->object);
10177 
10178                 if (IS_TMP_VAR != IS_CONST ||
10179                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
10180                     zval *object = call->object;
10181 
10182                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
10183                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
10184                         }
10185 
10186                         /* First, locate the function. */
10187                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
10188                         if (UNEXPECTED(call->fbc == NULL)) {
10189                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
10190                         }
10191                         if (IS_TMP_VAR == IS_CONST &&
10192                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
10193                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
10194                             EXPECTED(call->object == object)) {
10195                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
10196                         }
10197                 }
10198         } else {
10199                 if (UNEXPECTED(EG(exception) != NULL)) {
10200                         zval_dtor(free_op2.var);
10201                         HANDLE_EXCEPTION();
10202                 }
10203                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
10204         }
10205 
10206         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
10207                 call->object = NULL;
10208         } else {
10209                 if (!PZVAL_IS_REF(call->object)) {
10210                         Z_ADDREF_P(call->object); /* For $this pointer */
10211                 } else {
10212                         zval *this_ptr;
10213                         ALLOC_ZVAL(this_ptr);
10214                         INIT_PZVAL_COPY(this_ptr, call->object);
10215                         zval_copy_ctor(this_ptr);
10216                         call->object = this_ptr;
10217                 }
10218         }
10219 
10220         call->num_additional_args = 0;
10221         call->is_ctor_call = 0;
10222         EX(call) = call;
10223 
10224         zval_dtor(free_op2.var);
10225 
10226         CHECK_EXCEPTION();
10227         ZEND_VM_NEXT_OPCODE();
10228 }
10229 
10230 static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10231 {
10232         USE_OPLINE
10233         zend_free_op free_op1, free_op2;
10234 
10235         SAVE_OPLINE();
10236         is_equal_function(&EX_T(opline->result.var).tmp_var,
10237                                  _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10238                                  _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10239 
10240         zval_dtor(free_op2.var);
10241         CHECK_EXCEPTION();
10242         ZEND_VM_NEXT_OPCODE();
10243 }
10244 
10245 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10246 {
10247         USE_OPLINE
10248         zend_free_op free_op1;
10249         zval *expr_ptr;
10250 
10251         SAVE_OPLINE();
10252         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
10253                 zval **expr_ptr_ptr = NULL;
10254 
10255                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
10256                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
10257                 }
10258                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
10259                 expr_ptr = *expr_ptr_ptr;
10260                 Z_ADDREF_P(expr_ptr);
10261         } else {
10262                 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10263                 if (1) { /* temporary variable */
10264                         zval *new_expr;
10265 
10266                         ALLOC_ZVAL(new_expr);
10267                         INIT_PZVAL_COPY(new_expr, expr_ptr);
10268                         expr_ptr = new_expr;
10269                 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
10270                         zval *new_expr;
10271 
10272                         ALLOC_ZVAL(new_expr);
10273                         INIT_PZVAL_COPY(new_expr, expr_ptr);
10274                         expr_ptr = new_expr;
10275                         zendi_zval_copy_ctor(*expr_ptr);
10276 
10277                 } else if (IS_TMP_VAR == IS_CV) {
10278                         Z_ADDREF_P(expr_ptr);
10279                 }
10280         }
10281 
10282         if (IS_TMP_VAR != IS_UNUSED) {
10283                 zend_free_op free_op2;
10284                 zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10285                 ulong hval;
10286 
10287                 switch (Z_TYPE_P(offset)) {
10288                         case IS_DOUBLE:
10289                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
10290                                 goto num_index;
10291                         case IS_LONG:
10292                         case IS_BOOL:
10293                                 hval = Z_LVAL_P(offset);
10294 num_index:
10295                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
10296                                 break;
10297                         case IS_STRING:
10298                                 if (IS_TMP_VAR == IS_CONST) {
10299                                         hval = Z_HASH_P(offset);
10300                                 } else {
10301                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
10302                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
10303                                 }
10304                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
10305                                 break;
10306                         case IS_NULL:
10307                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
10308                                 break;
10309                         default:
10310                                 zend_error(E_WARNING, "Illegal offset type");
10311                                 zval_ptr_dtor(&expr_ptr);
10312                                 /* do nothing */
10313                                 break;
10314                 }
10315                 zval_dtor(free_op2.var);
10316         } else {
10317                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
10318         }
10319         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
10320 
10321         }
10322         CHECK_EXCEPTION();
10323         ZEND_VM_NEXT_OPCODE();
10324 }
10325 
10326 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10327 {
10328         USE_OPLINE
10329 
10330         array_init(&EX_T(opline->result.var).tmp_var);
10331         if (IS_TMP_VAR == IS_UNUSED) {
10332                 ZEND_VM_NEXT_OPCODE();
10333 #if 0 || IS_TMP_VAR != IS_UNUSED
10334         } else {
10335                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10336 #endif
10337         }
10338 }
10339 
10340 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10341 {
10342         USE_OPLINE
10343 
10344         /* The generator object is stored in return_value_ptr_ptr */
10345         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
10346 
10347         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
10348                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
10349         }
10350 
10351         /* Destroy the previously yielded value */
10352         if (generator->value) {
10353                 zval_ptr_dtor(&generator->value);
10354         }
10355 
10356         /* Destroy the previously yielded key */
10357         if (generator->key) {
10358                 zval_ptr_dtor(&generator->key);
10359         }
10360 
10361         /* Set the new yielded value */
10362         if (IS_TMP_VAR != IS_UNUSED) {
10363                 zend_free_op free_op1;
10364 
10365                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
10366                         /* Constants and temporary variables aren't yieldable by reference,
10367                          * but we still allow them with a notice. */
10368                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
10369                                 zval *value, *copy;
10370 
10371                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10372 
10373                                 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10374                                 ALLOC_ZVAL(copy);
10375                                 INIT_PZVAL_COPY(copy, value);
10376 
10377                                 /* Temporary variables don't need ctor copying */
10378                                 if (!1) {
10379                                         zval_copy_ctor(copy);
10380                                 }
10381 
10382                                 generator->value = copy;
10383                         } else {
10384                                 zval **value_ptr = NULL;
10385 
10386                                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
10387                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
10388                                 }
10389 
10390                                 /* If a function call result is yielded and the function did
10391                                  * not return by reference we throw a notice. */
10392                                 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
10393                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
10394                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
10395                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
10396                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10397 
10398                                         Z_ADDREF_PP(value_ptr);
10399                                         generator->value = *value_ptr;
10400                                 } else {
10401                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
10402                                         Z_ADDREF_PP(value_ptr);
10403                                         generator->value = *value_ptr;
10404                                 }
10405 
10406                         }
10407                 } else {
10408                         zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10409 
10410                         /* Consts, temporary variables and references need copying */
10411                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
10412                                 || PZVAL_IS_REF(value)
10413                         ) {
10414                                 zval *copy;
10415 
10416                                 ALLOC_ZVAL(copy);
10417                                 INIT_PZVAL_COPY(copy, value);
10418 
10419                                 /* Temporary variables don't need ctor copying */
10420                                 if (!1) {
10421                                         zval_copy_ctor(copy);
10422                                 }
10423 
10424                                 generator->value = copy;
10425 
10426                         } else {
10427                                 if (IS_TMP_VAR == IS_CV) {
10428                                         Z_ADDREF_P(value);
10429                                 }
10430                                 generator->value = value;
10431                         }
10432                 }
10433         } else {
10434                 /* If no value was specified yield null */
10435                 Z_ADDREF(EG(uninitialized_zval));
10436                 generator->value = &EG(uninitialized_zval);
10437         }
10438 
10439         /* Set the new yielded key */
10440         if (IS_TMP_VAR != IS_UNUSED) {
10441                 zend_free_op free_op2;
10442                 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10443 
10444                 /* Consts, temporary variables and references need copying */
10445                 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
10446                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
10447                 ) {
10448                         zval *copy;
10449 
10450                         ALLOC_ZVAL(copy);
10451                         INIT_PZVAL_COPY(copy, key);
10452 
10453                         /* Temporary variables don't need ctor copying */
10454                         if (!1) {
10455                                 zval_copy_ctor(copy);
10456                         }
10457 
10458                         generator->key = copy;
10459                 } else {
10460                         Z_ADDREF_P(key);
10461                         generator->key = key;
10462                 }
10463 
10464                 if (Z_TYPE_P(generator->key) == IS_LONG
10465                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
10466                 ) {
10467                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
10468                 }
10469 
10470         } else {
10471                 /* If no key was specified we use auto-increment keys */
10472                 generator->largest_used_integer_key++;
10473 
10474                 ALLOC_INIT_ZVAL(generator->key);
10475                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
10476         }
10477 
10478         if (RETURN_VALUE_USED(opline)) {
10479                 /* If the return value of yield is used set the send
10480                  * target and initialize it to NULL */
10481                 generator->send_target = &EX_T(opline->result.var).var.ptr;
10482                 Z_ADDREF(EG(uninitialized_zval));
10483                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
10484         } else {
10485                 generator->send_target = NULL;
10486         }
10487 
10488         /* We increment to the next op, so we are at the correct position when the
10489          * generator is resumed. */
10490         ZEND_VM_INC_OPCODE();
10491 
10492         /* The GOTO VM uses a local opline variable. We need to set the opline
10493          * variable in execute_data so we don't resume at an old position. */
10494         SAVE_OPLINE();
10495 
10496         ZEND_VM_RETURN();
10497 }
10498 
10499 static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10500 {
10501         USE_OPLINE
10502         zend_free_op free_op1, free_op2;
10503 
10504         SAVE_OPLINE();
10505         pow_function(&EX_T(opline->result.var).tmp_var,
10506                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10507                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10508         zval_dtor(free_op1.var);
10509         zval_dtor(free_op2.var);
10510         CHECK_EXCEPTION();
10511         ZEND_VM_NEXT_OPCODE();
10512 }
10513 
10514 static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10515 {
10516         USE_OPLINE
10517         zend_free_op free_op1, free_op2;
10518 
10519         SAVE_OPLINE();
10520         fast_add_function(&EX_T(opline->result.var).tmp_var,
10521                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10522                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10523         zval_dtor(free_op1.var);
10524         zval_ptr_dtor_nogc(&free_op2.var);
10525         CHECK_EXCEPTION();
10526         ZEND_VM_NEXT_OPCODE();
10527 }
10528 
10529 static int ZEND_FASTCALL  ZEND_SUB_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10530 {
10531         USE_OPLINE
10532         zend_free_op free_op1, free_op2;
10533 
10534         SAVE_OPLINE();
10535         fast_sub_function(&EX_T(opline->result.var).tmp_var,
10536                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10537                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10538         zval_dtor(free_op1.var);
10539         zval_ptr_dtor_nogc(&free_op2.var);
10540         CHECK_EXCEPTION();
10541         ZEND_VM_NEXT_OPCODE();
10542 }
10543 
10544 static int ZEND_FASTCALL  ZEND_MUL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10545 {
10546         USE_OPLINE
10547         zend_free_op free_op1, free_op2;
10548 
10549         SAVE_OPLINE();
10550         fast_mul_function(&EX_T(opline->result.var).tmp_var,
10551                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10552                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10553         zval_dtor(free_op1.var);
10554         zval_ptr_dtor_nogc(&free_op2.var);
10555         CHECK_EXCEPTION();
10556         ZEND_VM_NEXT_OPCODE();
10557 }
10558 
10559 static int ZEND_FASTCALL  ZEND_DIV_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10560 {
10561         USE_OPLINE
10562         zend_free_op free_op1, free_op2;
10563 
10564         SAVE_OPLINE();
10565         fast_div_function(&EX_T(opline->result.var).tmp_var,
10566                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10567                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10568         zval_dtor(free_op1.var);
10569         zval_ptr_dtor_nogc(&free_op2.var);
10570         CHECK_EXCEPTION();
10571         ZEND_VM_NEXT_OPCODE();
10572 }
10573 
10574 static int ZEND_FASTCALL  ZEND_MOD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10575 {
10576         USE_OPLINE
10577         zend_free_op free_op1, free_op2;
10578 
10579         SAVE_OPLINE();
10580         fast_mod_function(&EX_T(opline->result.var).tmp_var,
10581                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10582                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10583         zval_dtor(free_op1.var);
10584         zval_ptr_dtor_nogc(&free_op2.var);
10585         CHECK_EXCEPTION();
10586         ZEND_VM_NEXT_OPCODE();
10587 }
10588 
10589 static int ZEND_FASTCALL  ZEND_SL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10590 {
10591         USE_OPLINE
10592         zend_free_op free_op1, free_op2;
10593 
10594         SAVE_OPLINE();
10595         shift_left_function(&EX_T(opline->result.var).tmp_var,
10596                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10597                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10598         zval_dtor(free_op1.var);
10599         zval_ptr_dtor_nogc(&free_op2.var);
10600         CHECK_EXCEPTION();
10601         ZEND_VM_NEXT_OPCODE();
10602 }
10603 
10604 static int ZEND_FASTCALL  ZEND_SR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10605 {
10606         USE_OPLINE
10607         zend_free_op free_op1, free_op2;
10608 
10609         SAVE_OPLINE();
10610         shift_right_function(&EX_T(opline->result.var).tmp_var,
10611                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10612                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10613         zval_dtor(free_op1.var);
10614         zval_ptr_dtor_nogc(&free_op2.var);
10615         CHECK_EXCEPTION();
10616         ZEND_VM_NEXT_OPCODE();
10617 }
10618 
10619 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10620 {
10621         USE_OPLINE
10622         zend_free_op free_op1, free_op2;
10623 
10624         SAVE_OPLINE();
10625         concat_function(&EX_T(opline->result.var).tmp_var,
10626                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10627                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10628         zval_dtor(free_op1.var);
10629         zval_ptr_dtor_nogc(&free_op2.var);
10630         CHECK_EXCEPTION();
10631         ZEND_VM_NEXT_OPCODE();
10632 }
10633 
10634 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10635 {
10636         USE_OPLINE
10637         zend_free_op free_op1, free_op2;
10638 
10639         SAVE_OPLINE();
10640         is_identical_function(&EX_T(opline->result.var).tmp_var,
10641                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10642                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10643         zval_dtor(free_op1.var);
10644         zval_ptr_dtor_nogc(&free_op2.var);
10645         CHECK_EXCEPTION();
10646         ZEND_VM_NEXT_OPCODE();
10647 }
10648 
10649 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10650 {
10651         USE_OPLINE
10652         zend_free_op free_op1, free_op2;
10653         zval *result = &EX_T(opline->result.var).tmp_var;
10654 
10655         SAVE_OPLINE();
10656         is_identical_function(result,
10657                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10658                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10659         Z_LVAL_P(result) = !Z_LVAL_P(result);
10660         zval_dtor(free_op1.var);
10661         zval_ptr_dtor_nogc(&free_op2.var);
10662         CHECK_EXCEPTION();
10663         ZEND_VM_NEXT_OPCODE();
10664 }
10665 
10666 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10667 {
10668         USE_OPLINE
10669         zend_free_op free_op1, free_op2;
10670         zval *result = &EX_T(opline->result.var).tmp_var;
10671 
10672         SAVE_OPLINE();
10673         ZVAL_BOOL(result, fast_equal_function(result,
10674                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10675                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10676         zval_dtor(free_op1.var);
10677         zval_ptr_dtor_nogc(&free_op2.var);
10678         CHECK_EXCEPTION();
10679         ZEND_VM_NEXT_OPCODE();
10680 }
10681 
10682 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10683 {
10684         USE_OPLINE
10685         zend_free_op free_op1, free_op2;
10686         zval *result = &EX_T(opline->result.var).tmp_var;
10687 
10688         SAVE_OPLINE();
10689         ZVAL_BOOL(result, fast_not_equal_function(result,
10690                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10691                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10692         zval_dtor(free_op1.var);
10693         zval_ptr_dtor_nogc(&free_op2.var);
10694         CHECK_EXCEPTION();
10695         ZEND_VM_NEXT_OPCODE();
10696 }
10697 
10698 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10699 {
10700         USE_OPLINE
10701         zend_free_op free_op1, free_op2;
10702         zval *result = &EX_T(opline->result.var).tmp_var;
10703 
10704         SAVE_OPLINE();
10705         ZVAL_BOOL(result, fast_is_smaller_function(result,
10706                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10707                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10708         zval_dtor(free_op1.var);
10709         zval_ptr_dtor_nogc(&free_op2.var);
10710         CHECK_EXCEPTION();
10711         ZEND_VM_NEXT_OPCODE();
10712 }
10713 
10714 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10715 {
10716         USE_OPLINE
10717         zend_free_op free_op1, free_op2;
10718         zval *result = &EX_T(opline->result.var).tmp_var;
10719 
10720         SAVE_OPLINE();
10721         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
10722                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10723                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
10724         zval_dtor(free_op1.var);
10725         zval_ptr_dtor_nogc(&free_op2.var);
10726         CHECK_EXCEPTION();
10727         ZEND_VM_NEXT_OPCODE();
10728 }
10729 
10730 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10731 {
10732         USE_OPLINE
10733         zend_free_op free_op1, free_op2;
10734 
10735         SAVE_OPLINE();
10736         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
10737                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10738                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10739         zval_dtor(free_op1.var);
10740         zval_ptr_dtor_nogc(&free_op2.var);
10741         CHECK_EXCEPTION();
10742         ZEND_VM_NEXT_OPCODE();
10743 }
10744 
10745 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10746 {
10747         USE_OPLINE
10748         zend_free_op free_op1, free_op2;
10749 
10750         SAVE_OPLINE();
10751         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
10752                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10753                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10754         zval_dtor(free_op1.var);
10755         zval_ptr_dtor_nogc(&free_op2.var);
10756         CHECK_EXCEPTION();
10757         ZEND_VM_NEXT_OPCODE();
10758 }
10759 
10760 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10761 {
10762         USE_OPLINE
10763         zend_free_op free_op1, free_op2;
10764 
10765         SAVE_OPLINE();
10766         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
10767                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10768                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10769         zval_dtor(free_op1.var);
10770         zval_ptr_dtor_nogc(&free_op2.var);
10771         CHECK_EXCEPTION();
10772         ZEND_VM_NEXT_OPCODE();
10773 }
10774 
10775 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10776 {
10777         USE_OPLINE
10778         zend_free_op free_op1, free_op2;
10779 
10780         SAVE_OPLINE();
10781         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
10782                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
10783                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
10784         zval_dtor(free_op1.var);
10785         zval_ptr_dtor_nogc(&free_op2.var);
10786         CHECK_EXCEPTION();
10787         ZEND_VM_NEXT_OPCODE();
10788 }
10789 
10790 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
10791 {
10792         USE_OPLINE
10793         zend_free_op free_op1;
10794         zval *varname;
10795         zval **retval;
10796         zval tmp_varname;
10797         HashTable *target_symbol_table;
10798         ulong hash_value;
10799 
10800         SAVE_OPLINE();
10801         varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10802 
10803         if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
10804                 ZVAL_COPY_VALUE(&tmp_varname, varname);
10805                 zval_copy_ctor(&tmp_varname);
10806                 Z_SET_REFCOUNT(tmp_varname, 1);
10807                 Z_UNSET_ISREF(tmp_varname);
10808                 convert_to_string(&tmp_varname);
10809                 varname = &tmp_varname;
10810         }
10811 
10812         if (IS_VAR != IS_UNUSED) {
10813                 zend_class_entry *ce;
10814 
10815                 if (IS_VAR == IS_CONST) {
10816                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
10817                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
10818                         } else {
10819                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
10820                                 if (UNEXPECTED(ce == NULL)) {
10821                                         if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
10822                                                 zval_dtor(&tmp_varname);
10823                                         }
10824                                         zval_dtor(free_op1.var);
10825                                         CHECK_EXCEPTION();
10826                                         ZEND_VM_NEXT_OPCODE();
10827                                 }
10828                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
10829                         }
10830                 } else {
10831                         ce = EX_T(opline->op2.var).class_entry;
10832                 }
10833                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
10834                 zval_dtor(free_op1.var);
10835         } else {
10836                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
10837 /*
10838                 if (!target_symbol_table) {
10839                         CHECK_EXCEPTION();
10840                         ZEND_VM_NEXT_OPCODE();
10841                 }
10842 */
10843                 if (IS_TMP_VAR == IS_CONST) {
10844                         hash_value = Z_HASH_P(varname);
10845                 } else {
10846                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
10847                 }
10848 
10849                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
10850                         switch (type) {
10851                                 case BP_VAR_R:
10852                                 case BP_VAR_UNSET:
10853                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
10854                                         /* break missing intentionally */
10855                                 case BP_VAR_IS:
10856                                         retval = &EG(uninitialized_zval_ptr);
10857                                         break;
10858                                 case BP_VAR_RW:
10859                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
10860                                         /* break missing intentionally */
10861                                 case BP_VAR_W:
10862                                         Z_ADDREF_P(&EG(uninitialized_zval));
10863                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
10864                                         break;
10865                                 EMPTY_SWITCH_DEFAULT_CASE()
10866                         }
10867                 }
10868                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
10869                         case ZEND_FETCH_GLOBAL:
10870                                 if (IS_TMP_VAR != IS_TMP_VAR) {
10871                                         zval_dtor(free_op1.var);
10872                                 }
10873                                 break;
10874                         case ZEND_FETCH_LOCAL:
10875                                 zval_dtor(free_op1.var);
10876                                 break;
10877                         case ZEND_FETCH_STATIC:
10878                                 zval_update_constant(retval, 1 TSRMLS_CC);
10879                                 break;
10880                         case ZEND_FETCH_GLOBAL_LOCK:
10881                                 if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
10882                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
10883                                 }
10884                                 break;
10885                 }
10886         }
10887 
10888 
10889         if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
10890                 zval_dtor(&tmp_varname);
10891         }
10892         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
10893                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
10894         }
10895         PZVAL_LOCK(*retval);
10896         switch (type) {
10897                 case BP_VAR_R:
10898                 case BP_VAR_IS:
10899                         EX_T(opline->result.var).var.ptr = *retval;
10900                         break;
10901                 case BP_VAR_UNSET: {
10902                         zend_free_op free_res;
10903 
10904                         PZVAL_UNLOCK(*retval, &free_res);
10905                         if (retval != &EG(uninitialized_zval_ptr)) {
10906                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
10907                         }
10908                         PZVAL_LOCK(*retval);
10909                         FREE_OP_VAR_PTR(free_res);
10910                 }
10911                 /* break missing intentionally */
10912                 default:
10913                         EX_T(opline->result.var).var.ptr_ptr = retval;
10914                         break;
10915         }
10916         CHECK_EXCEPTION();
10917         ZEND_VM_NEXT_OPCODE();
10918 }
10919 
10920 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10921 {
10922         return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10923 }
10924 
10925 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10926 {
10927         return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10928 }
10929 
10930 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10931 {
10932         return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10933 }
10934 
10935 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10936 {
10937         USE_OPLINE
10938 
10939         return zend_fetch_var_address_helper_SPEC_TMP_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10940 }
10941 
10942 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10943 {
10944         return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10945 }
10946 
10947 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10948 {
10949         return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
10950 }
10951 
10952 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10953 {
10954         USE_OPLINE
10955         zend_free_op free_op1, free_op2;
10956         zval *container;
10957 
10958         SAVE_OPLINE();
10959         container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
10960         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
10961         zval_ptr_dtor_nogc(&free_op2.var);
10962         if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
10963                 zval_dtor(free_op1.var);
10964         }
10965         CHECK_EXCEPTION();
10966         ZEND_VM_NEXT_OPCODE();
10967 }
10968 
10969 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10970 {
10971         USE_OPLINE
10972         zend_free_op free_op2;
10973         zval *str = &EX_T(opline->result.var).tmp_var;
10974         zval *var;
10975         zval var_copy;
10976         int use_copy = 0;
10977 
10978         SAVE_OPLINE();
10979         var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
10980 
10981         if (IS_TMP_VAR == IS_UNUSED) {
10982                 /* Initialize for erealloc in add_string_to_string */
10983                 Z_STRVAL_P(str) = NULL;
10984                 Z_STRLEN_P(str) = 0;
10985                 Z_TYPE_P(str) = IS_STRING;
10986 
10987                 INIT_PZVAL(str);
10988         }
10989 
10990         if (Z_TYPE_P(var) != IS_STRING) {
10991                 zend_make_printable_zval(var, &var_copy, &use_copy);
10992 
10993                 if (use_copy) {
10994                         var = &var_copy;
10995                 }
10996         }
10997         add_string_to_string(str, str, var);
10998 
10999         if (use_copy) {
11000                 zval_dtor(var);
11001         }
11002         /* original comment, possibly problematic:
11003          * FREE_OP is missing intentionally here - we're always working on the same temporary variable
11004          * (Zeev):  I don't think it's problematic, we only use variables
11005          * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
11006          * string offsets or overloaded objects
11007          */
11008         zval_ptr_dtor_nogc(&free_op2.var);
11009 
11010         CHECK_EXCEPTION();
11011         ZEND_VM_NEXT_OPCODE();
11012 }
11013 
11014 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11015 {
11016         USE_OPLINE
11017         zval *function_name;
11018         char *function_name_strval;
11019         int function_name_strlen;
11020         zend_free_op free_op1, free_op2;
11021         call_slot *call = EX(call_slots) + opline->result.num;
11022 
11023         SAVE_OPLINE();
11024 
11025         function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
11026 
11027         if (IS_VAR != IS_CONST &&
11028             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
11029                 if (UNEXPECTED(EG(exception) != NULL)) {
11030                         HANDLE_EXCEPTION();
11031                 }
11032                 zend_error_noreturn(E_ERROR, "Method name must be a string");
11033         }
11034 
11035         function_name_strval = Z_STRVAL_P(function_name);
11036         function_name_strlen = Z_STRLEN_P(function_name);
11037 
11038         call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11039 
11040         if (EXPECTED(call->object != NULL) &&
11041             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
11042                 call->called_scope = Z_OBJCE_P(call->object);
11043 
11044                 if (IS_VAR != IS_CONST ||
11045                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
11046                     zval *object = call->object;
11047 
11048                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
11049                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
11050                         }
11051 
11052                         /* First, locate the function. */
11053                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
11054                         if (UNEXPECTED(call->fbc == NULL)) {
11055                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
11056                         }
11057                         if (IS_VAR == IS_CONST &&
11058                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
11059                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
11060                             EXPECTED(call->object == object)) {
11061                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
11062                         }
11063                 }
11064         } else {
11065                 if (UNEXPECTED(EG(exception) != NULL)) {
11066                         zval_ptr_dtor_nogc(&free_op2.var);
11067                         HANDLE_EXCEPTION();
11068                 }
11069                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
11070         }
11071 
11072         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
11073                 call->object = NULL;
11074         } else {
11075                 if (!PZVAL_IS_REF(call->object)) {
11076                         Z_ADDREF_P(call->object); /* For $this pointer */
11077                 } else {
11078                         zval *this_ptr;
11079                         ALLOC_ZVAL(this_ptr);
11080                         INIT_PZVAL_COPY(this_ptr, call->object);
11081                         zval_copy_ctor(this_ptr);
11082                         call->object = this_ptr;
11083                 }
11084         }
11085 
11086         call->num_additional_args = 0;
11087         call->is_ctor_call = 0;
11088         EX(call) = call;
11089 
11090         zval_ptr_dtor_nogc(&free_op2.var);
11091 
11092         CHECK_EXCEPTION();
11093         ZEND_VM_NEXT_OPCODE();
11094 }
11095 
11096 static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11097 {
11098         USE_OPLINE
11099         zend_free_op free_op1, free_op2;
11100 
11101         SAVE_OPLINE();
11102         is_equal_function(&EX_T(opline->result.var).tmp_var,
11103                                  _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
11104                                  _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
11105 
11106         zval_ptr_dtor_nogc(&free_op2.var);
11107         CHECK_EXCEPTION();
11108         ZEND_VM_NEXT_OPCODE();
11109 }
11110 
11111 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11112 {
11113         USE_OPLINE
11114         zend_free_op free_op1;
11115         zval *expr_ptr;
11116 
11117         SAVE_OPLINE();
11118         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
11119                 zval **expr_ptr_ptr = NULL;
11120 
11121                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
11122                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
11123                 }
11124                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
11125                 expr_ptr = *expr_ptr_ptr;
11126                 Z_ADDREF_P(expr_ptr);
11127         } else {
11128                 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11129                 if (1) { /* temporary variable */
11130                         zval *new_expr;
11131 
11132                         ALLOC_ZVAL(new_expr);
11133                         INIT_PZVAL_COPY(new_expr, expr_ptr);
11134                         expr_ptr = new_expr;
11135                 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
11136                         zval *new_expr;
11137 
11138                         ALLOC_ZVAL(new_expr);
11139                         INIT_PZVAL_COPY(new_expr, expr_ptr);
11140                         expr_ptr = new_expr;
11141                         zendi_zval_copy_ctor(*expr_ptr);
11142 
11143                 } else if (IS_TMP_VAR == IS_CV) {
11144                         Z_ADDREF_P(expr_ptr);
11145                 }
11146         }
11147 
11148         if (IS_VAR != IS_UNUSED) {
11149                 zend_free_op free_op2;
11150                 zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
11151                 ulong hval;
11152 
11153                 switch (Z_TYPE_P(offset)) {
11154                         case IS_DOUBLE:
11155                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
11156                                 goto num_index;
11157                         case IS_LONG:
11158                         case IS_BOOL:
11159                                 hval = Z_LVAL_P(offset);
11160 num_index:
11161                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
11162                                 break;
11163                         case IS_STRING:
11164                                 if (IS_VAR == IS_CONST) {
11165                                         hval = Z_HASH_P(offset);
11166                                 } else {
11167                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
11168                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
11169                                 }
11170                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
11171                                 break;
11172                         case IS_NULL:
11173                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
11174                                 break;
11175                         default:
11176                                 zend_error(E_WARNING, "Illegal offset type");
11177                                 zval_ptr_dtor(&expr_ptr);
11178                                 /* do nothing */
11179                                 break;
11180                 }
11181                 zval_ptr_dtor_nogc(&free_op2.var);
11182         } else {
11183                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
11184         }
11185         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
11186 
11187         }
11188         CHECK_EXCEPTION();
11189         ZEND_VM_NEXT_OPCODE();
11190 }
11191 
11192 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11193 {
11194         USE_OPLINE
11195 
11196         array_init(&EX_T(opline->result.var).tmp_var);
11197         if (IS_TMP_VAR == IS_UNUSED) {
11198                 ZEND_VM_NEXT_OPCODE();
11199 #if 0 || IS_TMP_VAR != IS_UNUSED
11200         } else {
11201                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11202 #endif
11203         }
11204 }
11205 
11206 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11207 {
11208         USE_OPLINE
11209         zval tmp, *varname;
11210         HashTable *target_symbol_table;
11211         zend_free_op free_op1;
11212 
11213         SAVE_OPLINE();
11214         if (IS_TMP_VAR == IS_CV &&
11215             IS_VAR == IS_UNUSED &&
11216             (opline->extended_value & ZEND_QUICK_SET)) {
11217                 if (EG(active_symbol_table)) {
11218                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
11219 
11220                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
11221                         EX_CV(opline->op1.var) = NULL;
11222                 } else if (EX_CV(opline->op1.var)) {
11223                         zval_ptr_dtor(EX_CV(opline->op1.var));
11224                         EX_CV(opline->op1.var) = NULL;
11225                 }
11226                 CHECK_EXCEPTION();
11227                 ZEND_VM_NEXT_OPCODE();
11228         }
11229 
11230         varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11231 
11232         if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
11233                 ZVAL_COPY_VALUE(&tmp, varname);
11234                 zval_copy_ctor(&tmp);
11235                 convert_to_string(&tmp);
11236                 varname = &tmp;
11237         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11238                 Z_ADDREF_P(varname);
11239         }
11240 
11241         if (IS_VAR != IS_UNUSED) {
11242                 zend_class_entry *ce;
11243 
11244                 if (IS_VAR == IS_CONST) {
11245                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11246                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
11247                         } else {
11248                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11249                                 if (UNEXPECTED(EG(exception) != NULL)) {
11250                                         if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11251                                                 zval_dtor(&tmp);
11252                                         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11253                                                 zval_ptr_dtor(&varname);
11254                                         }
11255                                         zval_dtor(free_op1.var);
11256                                         HANDLE_EXCEPTION();
11257                                 }
11258                                 if (UNEXPECTED(ce == NULL)) {
11259                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
11260                                 }
11261                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
11262                         }
11263                 } else {
11264                         ce = EX_T(opline->op2.var).class_entry;
11265                 }
11266                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11267         } else {
11268                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
11269 
11270                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11271                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
11272         }
11273 
11274         if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11275                 zval_dtor(&tmp);
11276         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11277                 zval_ptr_dtor(&varname);
11278         }
11279         zval_dtor(free_op1.var);
11280         CHECK_EXCEPTION();
11281         ZEND_VM_NEXT_OPCODE();
11282 }
11283 
11284 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11285 {
11286         USE_OPLINE
11287         zval **value;
11288         zend_bool isset = 1;
11289 
11290         SAVE_OPLINE();
11291         if (IS_TMP_VAR == IS_CV &&
11292             IS_VAR == IS_UNUSED &&
11293             (opline->extended_value & ZEND_QUICK_SET)) {
11294                 if (EX_CV(opline->op1.var)) {
11295                         value = EX_CV(opline->op1.var);
11296                 } else if (EG(active_symbol_table)) {
11297                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
11298 
11299                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
11300                                 isset = 0;
11301                         }
11302                 } else {
11303                         isset = 0;
11304                 }
11305         } else {
11306                 HashTable *target_symbol_table;
11307                 zend_free_op free_op1;
11308                 zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11309 
11310                 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
11311                         ZVAL_COPY_VALUE(&tmp, varname);
11312                         zval_copy_ctor(&tmp);
11313                         convert_to_string(&tmp);
11314                         varname = &tmp;
11315                 }
11316 
11317                 if (IS_VAR != IS_UNUSED) {
11318                         zend_class_entry *ce;
11319 
11320                         if (IS_VAR == IS_CONST) {
11321                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11322                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
11323                                 } else {
11324                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11325                                         if (UNEXPECTED(ce == NULL)) {
11326                                                 CHECK_EXCEPTION();
11327                                                 ZEND_VM_NEXT_OPCODE();
11328                                         }
11329                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
11330                                 }
11331                         } else {
11332                                 ce = EX_T(opline->op2.var).class_entry;
11333                         }
11334                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11335                         if (!value) {
11336                                 isset = 0;
11337                         }
11338                 } else {
11339                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11340                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
11341                                 isset = 0;
11342                         }
11343                 }
11344 
11345                 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11346                         zval_dtor(&tmp);
11347                 }
11348                 zval_dtor(free_op1.var);
11349         }
11350 
11351         if (opline->extended_value & ZEND_ISSET) {
11352                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
11353                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
11354                 } else {
11355                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
11356                 }
11357         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
11358                 if (!isset || !i_zend_is_true(*value)) {
11359                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
11360                 } else {
11361                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
11362                 }
11363         }
11364 
11365         CHECK_EXCEPTION();
11366         ZEND_VM_NEXT_OPCODE();
11367 }
11368 
11369 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11370 {
11371         USE_OPLINE
11372 
11373         /* The generator object is stored in return_value_ptr_ptr */
11374         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
11375 
11376         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
11377                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
11378         }
11379 
11380         /* Destroy the previously yielded value */
11381         if (generator->value) {
11382                 zval_ptr_dtor(&generator->value);
11383         }
11384 
11385         /* Destroy the previously yielded key */
11386         if (generator->key) {
11387                 zval_ptr_dtor(&generator->key);
11388         }
11389 
11390         /* Set the new yielded value */
11391         if (IS_TMP_VAR != IS_UNUSED) {
11392                 zend_free_op free_op1;
11393 
11394                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
11395                         /* Constants and temporary variables aren't yieldable by reference,
11396                          * but we still allow them with a notice. */
11397                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
11398                                 zval *value, *copy;
11399 
11400                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11401 
11402                                 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11403                                 ALLOC_ZVAL(copy);
11404                                 INIT_PZVAL_COPY(copy, value);
11405 
11406                                 /* Temporary variables don't need ctor copying */
11407                                 if (!1) {
11408                                         zval_copy_ctor(copy);
11409                                 }
11410 
11411                                 generator->value = copy;
11412                         } else {
11413                                 zval **value_ptr = NULL;
11414 
11415                                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
11416                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
11417                                 }
11418 
11419                                 /* If a function call result is yielded and the function did
11420                                  * not return by reference we throw a notice. */
11421                                 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
11422                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
11423                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
11424                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
11425                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11426 
11427                                         Z_ADDREF_PP(value_ptr);
11428                                         generator->value = *value_ptr;
11429                                 } else {
11430                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
11431                                         Z_ADDREF_PP(value_ptr);
11432                                         generator->value = *value_ptr;
11433                                 }
11434 
11435                         }
11436                 } else {
11437                         zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11438 
11439                         /* Consts, temporary variables and references need copying */
11440                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
11441                                 || PZVAL_IS_REF(value)
11442                         ) {
11443                                 zval *copy;
11444 
11445                                 ALLOC_ZVAL(copy);
11446                                 INIT_PZVAL_COPY(copy, value);
11447 
11448                                 /* Temporary variables don't need ctor copying */
11449                                 if (!1) {
11450                                         zval_copy_ctor(copy);
11451                                 }
11452 
11453                                 generator->value = copy;
11454 
11455                         } else {
11456                                 if (IS_TMP_VAR == IS_CV) {
11457                                         Z_ADDREF_P(value);
11458                                 }
11459                                 generator->value = value;
11460                         }
11461                 }
11462         } else {
11463                 /* If no value was specified yield null */
11464                 Z_ADDREF(EG(uninitialized_zval));
11465                 generator->value = &EG(uninitialized_zval);
11466         }
11467 
11468         /* Set the new yielded key */
11469         if (IS_VAR != IS_UNUSED) {
11470                 zend_free_op free_op2;
11471                 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
11472 
11473                 /* Consts, temporary variables and references need copying */
11474                 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
11475                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
11476                 ) {
11477                         zval *copy;
11478 
11479                         ALLOC_ZVAL(copy);
11480                         INIT_PZVAL_COPY(copy, key);
11481 
11482                         /* Temporary variables don't need ctor copying */
11483                         if (!0) {
11484                                 zval_copy_ctor(copy);
11485                         }
11486 
11487                         generator->key = copy;
11488                 } else {
11489                         Z_ADDREF_P(key);
11490                         generator->key = key;
11491                 }
11492 
11493                 if (Z_TYPE_P(generator->key) == IS_LONG
11494                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
11495                 ) {
11496                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
11497                 }
11498 
11499                 zval_ptr_dtor_nogc(&free_op2.var);
11500         } else {
11501                 /* If no key was specified we use auto-increment keys */
11502                 generator->largest_used_integer_key++;
11503 
11504                 ALLOC_INIT_ZVAL(generator->key);
11505                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
11506         }
11507 
11508         if (RETURN_VALUE_USED(opline)) {
11509                 /* If the return value of yield is used set the send
11510                  * target and initialize it to NULL */
11511                 generator->send_target = &EX_T(opline->result.var).var.ptr;
11512                 Z_ADDREF(EG(uninitialized_zval));
11513                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
11514         } else {
11515                 generator->send_target = NULL;
11516         }
11517 
11518         /* We increment to the next op, so we are at the correct position when the
11519          * generator is resumed. */
11520         ZEND_VM_INC_OPCODE();
11521 
11522         /* The GOTO VM uses a local opline variable. We need to set the opline
11523          * variable in execute_data so we don't resume at an old position. */
11524         SAVE_OPLINE();
11525 
11526         ZEND_VM_RETURN();
11527 }
11528 
11529 static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11530 {
11531         USE_OPLINE
11532         zend_free_op free_op1, free_op2;
11533 
11534         SAVE_OPLINE();
11535         pow_function(&EX_T(opline->result.var).tmp_var,
11536                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
11537                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
11538         zval_dtor(free_op1.var);
11539         zval_ptr_dtor_nogc(&free_op2.var);
11540         CHECK_EXCEPTION();
11541         ZEND_VM_NEXT_OPCODE();
11542 }
11543 
11544 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
11545 {
11546         USE_OPLINE
11547         zend_free_op free_op1;
11548         zval *varname;
11549         zval **retval;
11550         zval tmp_varname;
11551         HashTable *target_symbol_table;
11552         ulong hash_value;
11553 
11554         SAVE_OPLINE();
11555         varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11556 
11557         if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
11558                 ZVAL_COPY_VALUE(&tmp_varname, varname);
11559                 zval_copy_ctor(&tmp_varname);
11560                 Z_SET_REFCOUNT(tmp_varname, 1);
11561                 Z_UNSET_ISREF(tmp_varname);
11562                 convert_to_string(&tmp_varname);
11563                 varname = &tmp_varname;
11564         }
11565 
11566         if (IS_UNUSED != IS_UNUSED) {
11567                 zend_class_entry *ce;
11568 
11569                 if (IS_UNUSED == IS_CONST) {
11570                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11571                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
11572                         } else {
11573                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11574                                 if (UNEXPECTED(ce == NULL)) {
11575                                         if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
11576                                                 zval_dtor(&tmp_varname);
11577                                         }
11578                                         zval_dtor(free_op1.var);
11579                                         CHECK_EXCEPTION();
11580                                         ZEND_VM_NEXT_OPCODE();
11581                                 }
11582                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
11583                         }
11584                 } else {
11585                         ce = EX_T(opline->op2.var).class_entry;
11586                 }
11587                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11588                 zval_dtor(free_op1.var);
11589         } else {
11590                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11591 /*
11592                 if (!target_symbol_table) {
11593                         CHECK_EXCEPTION();
11594                         ZEND_VM_NEXT_OPCODE();
11595                 }
11596 */
11597                 if (IS_TMP_VAR == IS_CONST) {
11598                         hash_value = Z_HASH_P(varname);
11599                 } else {
11600                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
11601                 }
11602 
11603                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
11604                         switch (type) {
11605                                 case BP_VAR_R:
11606                                 case BP_VAR_UNSET:
11607                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
11608                                         /* break missing intentionally */
11609                                 case BP_VAR_IS:
11610                                         retval = &EG(uninitialized_zval_ptr);
11611                                         break;
11612                                 case BP_VAR_RW:
11613                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
11614                                         /* break missing intentionally */
11615                                 case BP_VAR_W:
11616                                         Z_ADDREF_P(&EG(uninitialized_zval));
11617                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
11618                                         break;
11619                                 EMPTY_SWITCH_DEFAULT_CASE()
11620                         }
11621                 }
11622                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
11623                         case ZEND_FETCH_GLOBAL:
11624                                 if (IS_TMP_VAR != IS_TMP_VAR) {
11625                                         zval_dtor(free_op1.var);
11626                                 }
11627                                 break;
11628                         case ZEND_FETCH_LOCAL:
11629                                 zval_dtor(free_op1.var);
11630                                 break;
11631                         case ZEND_FETCH_STATIC:
11632                                 zval_update_constant(retval, 1 TSRMLS_CC);
11633                                 break;
11634                         case ZEND_FETCH_GLOBAL_LOCK:
11635                                 if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
11636                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
11637                                 }
11638                                 break;
11639                 }
11640         }
11641 
11642 
11643         if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
11644                 zval_dtor(&tmp_varname);
11645         }
11646         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
11647                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
11648         }
11649         PZVAL_LOCK(*retval);
11650         switch (type) {
11651                 case BP_VAR_R:
11652                 case BP_VAR_IS:
11653                         EX_T(opline->result.var).var.ptr = *retval;
11654                         break;
11655                 case BP_VAR_UNSET: {
11656                         zend_free_op free_res;
11657 
11658                         PZVAL_UNLOCK(*retval, &free_res);
11659                         if (retval != &EG(uninitialized_zval_ptr)) {
11660                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
11661                         }
11662                         PZVAL_LOCK(*retval);
11663                         FREE_OP_VAR_PTR(free_res);
11664                 }
11665                 /* break missing intentionally */
11666                 default:
11667                         EX_T(opline->result.var).var.ptr_ptr = retval;
11668                         break;
11669         }
11670         CHECK_EXCEPTION();
11671         ZEND_VM_NEXT_OPCODE();
11672 }
11673 
11674 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11675 {
11676         return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11677 }
11678 
11679 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11680 {
11681         return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11682 }
11683 
11684 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11685 {
11686         return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11687 }
11688 
11689 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11690 {
11691         USE_OPLINE
11692 
11693         return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11694 }
11695 
11696 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11697 {
11698         return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11699 }
11700 
11701 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11702 {
11703         return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11704 }
11705 
11706 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11707 {
11708         USE_OPLINE
11709         zend_free_op free_op1;
11710         zval *expr_ptr;
11711 
11712         SAVE_OPLINE();
11713         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
11714                 zval **expr_ptr_ptr = NULL;
11715 
11716                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
11717                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
11718                 }
11719                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
11720                 expr_ptr = *expr_ptr_ptr;
11721                 Z_ADDREF_P(expr_ptr);
11722         } else {
11723                 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11724                 if (1) { /* temporary variable */
11725                         zval *new_expr;
11726 
11727                         ALLOC_ZVAL(new_expr);
11728                         INIT_PZVAL_COPY(new_expr, expr_ptr);
11729                         expr_ptr = new_expr;
11730                 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
11731                         zval *new_expr;
11732 
11733                         ALLOC_ZVAL(new_expr);
11734                         INIT_PZVAL_COPY(new_expr, expr_ptr);
11735                         expr_ptr = new_expr;
11736                         zendi_zval_copy_ctor(*expr_ptr);
11737 
11738                 } else if (IS_TMP_VAR == IS_CV) {
11739                         Z_ADDREF_P(expr_ptr);
11740                 }
11741         }
11742 
11743         if (IS_UNUSED != IS_UNUSED) {
11744 
11745                 zval *offset = NULL;
11746                 ulong hval;
11747 
11748                 switch (Z_TYPE_P(offset)) {
11749                         case IS_DOUBLE:
11750                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
11751                                 goto num_index;
11752                         case IS_LONG:
11753                         case IS_BOOL:
11754                                 hval = Z_LVAL_P(offset);
11755 num_index:
11756                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
11757                                 break;
11758                         case IS_STRING:
11759                                 if (IS_UNUSED == IS_CONST) {
11760                                         hval = Z_HASH_P(offset);
11761                                 } else {
11762                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
11763                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
11764                                 }
11765                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
11766                                 break;
11767                         case IS_NULL:
11768                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
11769                                 break;
11770                         default:
11771                                 zend_error(E_WARNING, "Illegal offset type");
11772                                 zval_ptr_dtor(&expr_ptr);
11773                                 /* do nothing */
11774                                 break;
11775                 }
11776 
11777         } else {
11778                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
11779         }
11780         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
11781 
11782         }
11783         CHECK_EXCEPTION();
11784         ZEND_VM_NEXT_OPCODE();
11785 }
11786 
11787 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11788 {
11789         USE_OPLINE
11790 
11791         array_init(&EX_T(opline->result.var).tmp_var);
11792         if (IS_TMP_VAR == IS_UNUSED) {
11793                 ZEND_VM_NEXT_OPCODE();
11794 #if 0 || IS_TMP_VAR != IS_UNUSED
11795         } else {
11796                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
11797 #endif
11798         }
11799 }
11800 
11801 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11802 {
11803         USE_OPLINE
11804         zval tmp, *varname;
11805         HashTable *target_symbol_table;
11806         zend_free_op free_op1;
11807 
11808         SAVE_OPLINE();
11809         if (IS_TMP_VAR == IS_CV &&
11810             IS_UNUSED == IS_UNUSED &&
11811             (opline->extended_value & ZEND_QUICK_SET)) {
11812                 if (EG(active_symbol_table)) {
11813                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
11814 
11815                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
11816                         EX_CV(opline->op1.var) = NULL;
11817                 } else if (EX_CV(opline->op1.var)) {
11818                         zval_ptr_dtor(EX_CV(opline->op1.var));
11819                         EX_CV(opline->op1.var) = NULL;
11820                 }
11821                 CHECK_EXCEPTION();
11822                 ZEND_VM_NEXT_OPCODE();
11823         }
11824 
11825         varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11826 
11827         if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
11828                 ZVAL_COPY_VALUE(&tmp, varname);
11829                 zval_copy_ctor(&tmp);
11830                 convert_to_string(&tmp);
11831                 varname = &tmp;
11832         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11833                 Z_ADDREF_P(varname);
11834         }
11835 
11836         if (IS_UNUSED != IS_UNUSED) {
11837                 zend_class_entry *ce;
11838 
11839                 if (IS_UNUSED == IS_CONST) {
11840                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11841                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
11842                         } else {
11843                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11844                                 if (UNEXPECTED(EG(exception) != NULL)) {
11845                                         if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11846                                                 zval_dtor(&tmp);
11847                                         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11848                                                 zval_ptr_dtor(&varname);
11849                                         }
11850                                         zval_dtor(free_op1.var);
11851                                         HANDLE_EXCEPTION();
11852                                 }
11853                                 if (UNEXPECTED(ce == NULL)) {
11854                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
11855                                 }
11856                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
11857                         }
11858                 } else {
11859                         ce = EX_T(opline->op2.var).class_entry;
11860                 }
11861                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11862         } else {
11863                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
11864 
11865                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11866                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
11867         }
11868 
11869         if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11870                 zval_dtor(&tmp);
11871         } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
11872                 zval_ptr_dtor(&varname);
11873         }
11874         zval_dtor(free_op1.var);
11875         CHECK_EXCEPTION();
11876         ZEND_VM_NEXT_OPCODE();
11877 }
11878 
11879 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11880 {
11881         USE_OPLINE
11882         zval **value;
11883         zend_bool isset = 1;
11884 
11885         SAVE_OPLINE();
11886         if (IS_TMP_VAR == IS_CV &&
11887             IS_UNUSED == IS_UNUSED &&
11888             (opline->extended_value & ZEND_QUICK_SET)) {
11889                 if (EX_CV(opline->op1.var)) {
11890                         value = EX_CV(opline->op1.var);
11891                 } else if (EG(active_symbol_table)) {
11892                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
11893 
11894                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
11895                                 isset = 0;
11896                         }
11897                 } else {
11898                         isset = 0;
11899                 }
11900         } else {
11901                 HashTable *target_symbol_table;
11902                 zend_free_op free_op1;
11903                 zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11904 
11905                 if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
11906                         ZVAL_COPY_VALUE(&tmp, varname);
11907                         zval_copy_ctor(&tmp);
11908                         convert_to_string(&tmp);
11909                         varname = &tmp;
11910                 }
11911 
11912                 if (IS_UNUSED != IS_UNUSED) {
11913                         zend_class_entry *ce;
11914 
11915                         if (IS_UNUSED == IS_CONST) {
11916                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
11917                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
11918                                 } else {
11919                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
11920                                         if (UNEXPECTED(ce == NULL)) {
11921                                                 CHECK_EXCEPTION();
11922                                                 ZEND_VM_NEXT_OPCODE();
11923                                         }
11924                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
11925                                 }
11926                         } else {
11927                                 ce = EX_T(opline->op2.var).class_entry;
11928                         }
11929                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
11930                         if (!value) {
11931                                 isset = 0;
11932                         }
11933                 } else {
11934                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
11935                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
11936                                 isset = 0;
11937                         }
11938                 }
11939 
11940                 if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
11941                         zval_dtor(&tmp);
11942                 }
11943                 zval_dtor(free_op1.var);
11944         }
11945 
11946         if (opline->extended_value & ZEND_ISSET) {
11947                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
11948                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
11949                 } else {
11950                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
11951                 }
11952         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
11953                 if (!isset || !i_zend_is_true(*value)) {
11954                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
11955                 } else {
11956                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
11957                 }
11958         }
11959 
11960         CHECK_EXCEPTION();
11961         ZEND_VM_NEXT_OPCODE();
11962 }
11963 
11964 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11965 {
11966         USE_OPLINE
11967 
11968         /* The generator object is stored in return_value_ptr_ptr */
11969         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
11970 
11971         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
11972                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
11973         }
11974 
11975         /* Destroy the previously yielded value */
11976         if (generator->value) {
11977                 zval_ptr_dtor(&generator->value);
11978         }
11979 
11980         /* Destroy the previously yielded key */
11981         if (generator->key) {
11982                 zval_ptr_dtor(&generator->key);
11983         }
11984 
11985         /* Set the new yielded value */
11986         if (IS_TMP_VAR != IS_UNUSED) {
11987                 zend_free_op free_op1;
11988 
11989                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
11990                         /* Constants and temporary variables aren't yieldable by reference,
11991                          * but we still allow them with a notice. */
11992                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
11993                                 zval *value, *copy;
11994 
11995                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11996 
11997                                 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
11998                                 ALLOC_ZVAL(copy);
11999                                 INIT_PZVAL_COPY(copy, value);
12000 
12001                                 /* Temporary variables don't need ctor copying */
12002                                 if (!1) {
12003                                         zval_copy_ctor(copy);
12004                                 }
12005 
12006                                 generator->value = copy;
12007                         } else {
12008                                 zval **value_ptr = NULL;
12009 
12010                                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
12011                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
12012                                 }
12013 
12014                                 /* If a function call result is yielded and the function did
12015                                  * not return by reference we throw a notice. */
12016                                 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
12017                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
12018                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
12019                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
12020                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12021 
12022                                         Z_ADDREF_PP(value_ptr);
12023                                         generator->value = *value_ptr;
12024                                 } else {
12025                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
12026                                         Z_ADDREF_PP(value_ptr);
12027                                         generator->value = *value_ptr;
12028                                 }
12029 
12030                         }
12031                 } else {
12032                         zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12033 
12034                         /* Consts, temporary variables and references need copying */
12035                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
12036                                 || PZVAL_IS_REF(value)
12037                         ) {
12038                                 zval *copy;
12039 
12040                                 ALLOC_ZVAL(copy);
12041                                 INIT_PZVAL_COPY(copy, value);
12042 
12043                                 /* Temporary variables don't need ctor copying */
12044                                 if (!1) {
12045                                         zval_copy_ctor(copy);
12046                                 }
12047 
12048                                 generator->value = copy;
12049 
12050                         } else {
12051                                 if (IS_TMP_VAR == IS_CV) {
12052                                         Z_ADDREF_P(value);
12053                                 }
12054                                 generator->value = value;
12055                         }
12056                 }
12057         } else {
12058                 /* If no value was specified yield null */
12059                 Z_ADDREF(EG(uninitialized_zval));
12060                 generator->value = &EG(uninitialized_zval);
12061         }
12062 
12063         /* Set the new yielded key */
12064         if (IS_UNUSED != IS_UNUSED) {
12065 
12066                 zval *key = NULL;
12067 
12068                 /* Consts, temporary variables and references need copying */
12069                 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
12070                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
12071                 ) {
12072                         zval *copy;
12073 
12074                         ALLOC_ZVAL(copy);
12075                         INIT_PZVAL_COPY(copy, key);
12076 
12077                         /* Temporary variables don't need ctor copying */
12078                         if (!0) {
12079                                 zval_copy_ctor(copy);
12080                         }
12081 
12082                         generator->key = copy;
12083                 } else {
12084                         Z_ADDREF_P(key);
12085                         generator->key = key;
12086                 }
12087 
12088                 if (Z_TYPE_P(generator->key) == IS_LONG
12089                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
12090                 ) {
12091                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
12092                 }
12093 
12094         } else {
12095                 /* If no key was specified we use auto-increment keys */
12096                 generator->largest_used_integer_key++;
12097 
12098                 ALLOC_INIT_ZVAL(generator->key);
12099                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
12100         }
12101 
12102         if (RETURN_VALUE_USED(opline)) {
12103                 /* If the return value of yield is used set the send
12104                  * target and initialize it to NULL */
12105                 generator->send_target = &EX_T(opline->result.var).var.ptr;
12106                 Z_ADDREF(EG(uninitialized_zval));
12107                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
12108         } else {
12109                 generator->send_target = NULL;
12110         }
12111 
12112         /* We increment to the next op, so we are at the correct position when the
12113          * generator is resumed. */
12114         ZEND_VM_INC_OPCODE();
12115 
12116         /* The GOTO VM uses a local opline variable. We need to set the opline
12117          * variable in execute_data so we don't resume at an old position. */
12118         SAVE_OPLINE();
12119 
12120         ZEND_VM_RETURN();
12121 }
12122 
12123 static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12124 {
12125         USE_OPLINE
12126         zend_free_op free_op1;
12127 
12128         SAVE_OPLINE();
12129         fast_add_function(&EX_T(opline->result.var).tmp_var,
12130                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12131                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12132         zval_dtor(free_op1.var);
12133 
12134         CHECK_EXCEPTION();
12135         ZEND_VM_NEXT_OPCODE();
12136 }
12137 
12138 static int ZEND_FASTCALL  ZEND_SUB_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12139 {
12140         USE_OPLINE
12141         zend_free_op free_op1;
12142 
12143         SAVE_OPLINE();
12144         fast_sub_function(&EX_T(opline->result.var).tmp_var,
12145                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12146                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12147         zval_dtor(free_op1.var);
12148 
12149         CHECK_EXCEPTION();
12150         ZEND_VM_NEXT_OPCODE();
12151 }
12152 
12153 static int ZEND_FASTCALL  ZEND_MUL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12154 {
12155         USE_OPLINE
12156         zend_free_op free_op1;
12157 
12158         SAVE_OPLINE();
12159         fast_mul_function(&EX_T(opline->result.var).tmp_var,
12160                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12161                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12162         zval_dtor(free_op1.var);
12163 
12164         CHECK_EXCEPTION();
12165         ZEND_VM_NEXT_OPCODE();
12166 }
12167 
12168 static int ZEND_FASTCALL  ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12169 {
12170         USE_OPLINE
12171         zend_free_op free_op1;
12172 
12173         SAVE_OPLINE();
12174         fast_div_function(&EX_T(opline->result.var).tmp_var,
12175                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12176                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12177         zval_dtor(free_op1.var);
12178 
12179         CHECK_EXCEPTION();
12180         ZEND_VM_NEXT_OPCODE();
12181 }
12182 
12183 static int ZEND_FASTCALL  ZEND_MOD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12184 {
12185         USE_OPLINE
12186         zend_free_op free_op1;
12187 
12188         SAVE_OPLINE();
12189         fast_mod_function(&EX_T(opline->result.var).tmp_var,
12190                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12191                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12192         zval_dtor(free_op1.var);
12193 
12194         CHECK_EXCEPTION();
12195         ZEND_VM_NEXT_OPCODE();
12196 }
12197 
12198 static int ZEND_FASTCALL  ZEND_SL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12199 {
12200         USE_OPLINE
12201         zend_free_op free_op1;
12202 
12203         SAVE_OPLINE();
12204         shift_left_function(&EX_T(opline->result.var).tmp_var,
12205                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12206                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12207         zval_dtor(free_op1.var);
12208 
12209         CHECK_EXCEPTION();
12210         ZEND_VM_NEXT_OPCODE();
12211 }
12212 
12213 static int ZEND_FASTCALL  ZEND_SR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12214 {
12215         USE_OPLINE
12216         zend_free_op free_op1;
12217 
12218         SAVE_OPLINE();
12219         shift_right_function(&EX_T(opline->result.var).tmp_var,
12220                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12221                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12222         zval_dtor(free_op1.var);
12223 
12224         CHECK_EXCEPTION();
12225         ZEND_VM_NEXT_OPCODE();
12226 }
12227 
12228 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12229 {
12230         USE_OPLINE
12231         zend_free_op free_op1;
12232 
12233         SAVE_OPLINE();
12234         concat_function(&EX_T(opline->result.var).tmp_var,
12235                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12236                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12237         zval_dtor(free_op1.var);
12238 
12239         CHECK_EXCEPTION();
12240         ZEND_VM_NEXT_OPCODE();
12241 }
12242 
12243 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12244 {
12245         USE_OPLINE
12246         zend_free_op free_op1;
12247 
12248         SAVE_OPLINE();
12249         is_identical_function(&EX_T(opline->result.var).tmp_var,
12250                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12251                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12252         zval_dtor(free_op1.var);
12253 
12254         CHECK_EXCEPTION();
12255         ZEND_VM_NEXT_OPCODE();
12256 }
12257 
12258 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12259 {
12260         USE_OPLINE
12261         zend_free_op free_op1;
12262         zval *result = &EX_T(opline->result.var).tmp_var;
12263 
12264         SAVE_OPLINE();
12265         is_identical_function(result,
12266                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12267                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12268         Z_LVAL_P(result) = !Z_LVAL_P(result);
12269         zval_dtor(free_op1.var);
12270 
12271         CHECK_EXCEPTION();
12272         ZEND_VM_NEXT_OPCODE();
12273 }
12274 
12275 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12276 {
12277         USE_OPLINE
12278         zend_free_op free_op1;
12279         zval *result = &EX_T(opline->result.var).tmp_var;
12280 
12281         SAVE_OPLINE();
12282         ZVAL_BOOL(result, fast_equal_function(result,
12283                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12284                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
12285         zval_dtor(free_op1.var);
12286 
12287         CHECK_EXCEPTION();
12288         ZEND_VM_NEXT_OPCODE();
12289 }
12290 
12291 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12292 {
12293         USE_OPLINE
12294         zend_free_op free_op1;
12295         zval *result = &EX_T(opline->result.var).tmp_var;
12296 
12297         SAVE_OPLINE();
12298         ZVAL_BOOL(result, fast_not_equal_function(result,
12299                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12300                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
12301         zval_dtor(free_op1.var);
12302 
12303         CHECK_EXCEPTION();
12304         ZEND_VM_NEXT_OPCODE();
12305 }
12306 
12307 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12308 {
12309         USE_OPLINE
12310         zend_free_op free_op1;
12311         zval *result = &EX_T(opline->result.var).tmp_var;
12312 
12313         SAVE_OPLINE();
12314         ZVAL_BOOL(result, fast_is_smaller_function(result,
12315                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12316                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
12317         zval_dtor(free_op1.var);
12318 
12319         CHECK_EXCEPTION();
12320         ZEND_VM_NEXT_OPCODE();
12321 }
12322 
12323 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12324 {
12325         USE_OPLINE
12326         zend_free_op free_op1;
12327         zval *result = &EX_T(opline->result.var).tmp_var;
12328 
12329         SAVE_OPLINE();
12330         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
12331                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12332                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
12333         zval_dtor(free_op1.var);
12334 
12335         CHECK_EXCEPTION();
12336         ZEND_VM_NEXT_OPCODE();
12337 }
12338 
12339 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12340 {
12341         USE_OPLINE
12342         zend_free_op free_op1;
12343 
12344         SAVE_OPLINE();
12345         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
12346                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12347                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12348         zval_dtor(free_op1.var);
12349 
12350         CHECK_EXCEPTION();
12351         ZEND_VM_NEXT_OPCODE();
12352 }
12353 
12354 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12355 {
12356         USE_OPLINE
12357         zend_free_op free_op1;
12358 
12359         SAVE_OPLINE();
12360         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
12361                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12362                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12363         zval_dtor(free_op1.var);
12364 
12365         CHECK_EXCEPTION();
12366         ZEND_VM_NEXT_OPCODE();
12367 }
12368 
12369 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12370 {
12371         USE_OPLINE
12372         zend_free_op free_op1;
12373 
12374         SAVE_OPLINE();
12375         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
12376                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12377                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12378         zval_dtor(free_op1.var);
12379 
12380         CHECK_EXCEPTION();
12381         ZEND_VM_NEXT_OPCODE();
12382 }
12383 
12384 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12385 {
12386         USE_OPLINE
12387         zend_free_op free_op1;
12388 
12389         SAVE_OPLINE();
12390         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
12391                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12392                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12393         zval_dtor(free_op1.var);
12394 
12395         CHECK_EXCEPTION();
12396         ZEND_VM_NEXT_OPCODE();
12397 }
12398 
12399 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12400 {
12401         USE_OPLINE
12402         zend_free_op free_op1;
12403         zval *container;
12404 
12405         SAVE_OPLINE();
12406         container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12407         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
12408 
12409         if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
12410                 zval_dtor(free_op1.var);
12411         }
12412         CHECK_EXCEPTION();
12413         ZEND_VM_NEXT_OPCODE();
12414 }
12415 
12416 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12417 {
12418         USE_OPLINE
12419 
12420         zval *str = &EX_T(opline->result.var).tmp_var;
12421         zval *var;
12422         zval var_copy;
12423         int use_copy = 0;
12424 
12425         SAVE_OPLINE();
12426         var = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
12427 
12428         if (IS_TMP_VAR == IS_UNUSED) {
12429                 /* Initialize for erealloc in add_string_to_string */
12430                 Z_STRVAL_P(str) = NULL;
12431                 Z_STRLEN_P(str) = 0;
12432                 Z_TYPE_P(str) = IS_STRING;
12433 
12434                 INIT_PZVAL(str);
12435         }
12436 
12437         if (Z_TYPE_P(var) != IS_STRING) {
12438                 zend_make_printable_zval(var, &var_copy, &use_copy);
12439 
12440                 if (use_copy) {
12441                         var = &var_copy;
12442                 }
12443         }
12444         add_string_to_string(str, str, var);
12445 
12446         if (use_copy) {
12447                 zval_dtor(var);
12448         }
12449         /* original comment, possibly problematic:
12450          * FREE_OP is missing intentionally here - we're always working on the same temporary variable
12451          * (Zeev):  I don't think it's problematic, we only use variables
12452          * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
12453          * string offsets or overloaded objects
12454          */
12455 
12456         CHECK_EXCEPTION();
12457         ZEND_VM_NEXT_OPCODE();
12458 }
12459 
12460 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12461 {
12462         USE_OPLINE
12463         zval *function_name;
12464         char *function_name_strval;
12465         int function_name_strlen;
12466         zend_free_op free_op1;
12467         call_slot *call = EX(call_slots) + opline->result.num;
12468 
12469         SAVE_OPLINE();
12470 
12471         function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
12472 
12473         if (IS_CV != IS_CONST &&
12474             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12475                 if (UNEXPECTED(EG(exception) != NULL)) {
12476                         HANDLE_EXCEPTION();
12477                 }
12478                 zend_error_noreturn(E_ERROR, "Method name must be a string");
12479         }
12480 
12481         function_name_strval = Z_STRVAL_P(function_name);
12482         function_name_strlen = Z_STRLEN_P(function_name);
12483 
12484         call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12485 
12486         if (EXPECTED(call->object != NULL) &&
12487             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
12488                 call->called_scope = Z_OBJCE_P(call->object);
12489 
12490                 if (IS_CV != IS_CONST ||
12491                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
12492                     zval *object = call->object;
12493 
12494                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
12495                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
12496                         }
12497 
12498                         /* First, locate the function. */
12499                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
12500                         if (UNEXPECTED(call->fbc == NULL)) {
12501                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
12502                         }
12503                         if (IS_CV == IS_CONST &&
12504                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
12505                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
12506                             EXPECTED(call->object == object)) {
12507                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
12508                         }
12509                 }
12510         } else {
12511                 if (UNEXPECTED(EG(exception) != NULL)) {
12512 
12513                         HANDLE_EXCEPTION();
12514                 }
12515                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
12516         }
12517 
12518         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
12519                 call->object = NULL;
12520         } else {
12521                 if (!PZVAL_IS_REF(call->object)) {
12522                         Z_ADDREF_P(call->object); /* For $this pointer */
12523                 } else {
12524                         zval *this_ptr;
12525                         ALLOC_ZVAL(this_ptr);
12526                         INIT_PZVAL_COPY(this_ptr, call->object);
12527                         zval_copy_ctor(this_ptr);
12528                         call->object = this_ptr;
12529                 }
12530         }
12531 
12532         call->num_additional_args = 0;
12533         call->is_ctor_call = 0;
12534         EX(call) = call;
12535 
12536 
12537         CHECK_EXCEPTION();
12538         ZEND_VM_NEXT_OPCODE();
12539 }
12540 
12541 static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12542 {
12543         USE_OPLINE
12544         zend_free_op free_op1;
12545 
12546         SAVE_OPLINE();
12547         is_equal_function(&EX_T(opline->result.var).tmp_var,
12548                                  _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12549                                  _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12550 
12551         CHECK_EXCEPTION();
12552         ZEND_VM_NEXT_OPCODE();
12553 }
12554 
12555 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12556 {
12557         USE_OPLINE
12558         zend_free_op free_op1;
12559         zval *expr_ptr;
12560 
12561         SAVE_OPLINE();
12562         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
12563                 zval **expr_ptr_ptr = NULL;
12564 
12565                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
12566                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
12567                 }
12568                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
12569                 expr_ptr = *expr_ptr_ptr;
12570                 Z_ADDREF_P(expr_ptr);
12571         } else {
12572                 expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12573                 if (1) { /* temporary variable */
12574                         zval *new_expr;
12575 
12576                         ALLOC_ZVAL(new_expr);
12577                         INIT_PZVAL_COPY(new_expr, expr_ptr);
12578                         expr_ptr = new_expr;
12579                 } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
12580                         zval *new_expr;
12581 
12582                         ALLOC_ZVAL(new_expr);
12583                         INIT_PZVAL_COPY(new_expr, expr_ptr);
12584                         expr_ptr = new_expr;
12585                         zendi_zval_copy_ctor(*expr_ptr);
12586 
12587                 } else if (IS_TMP_VAR == IS_CV) {
12588                         Z_ADDREF_P(expr_ptr);
12589                 }
12590         }
12591 
12592         if (IS_CV != IS_UNUSED) {
12593 
12594                 zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
12595                 ulong hval;
12596 
12597                 switch (Z_TYPE_P(offset)) {
12598                         case IS_DOUBLE:
12599                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
12600                                 goto num_index;
12601                         case IS_LONG:
12602                         case IS_BOOL:
12603                                 hval = Z_LVAL_P(offset);
12604 num_index:
12605                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
12606                                 break;
12607                         case IS_STRING:
12608                                 if (IS_CV == IS_CONST) {
12609                                         hval = Z_HASH_P(offset);
12610                                 } else {
12611                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
12612                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
12613                                 }
12614                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
12615                                 break;
12616                         case IS_NULL:
12617                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
12618                                 break;
12619                         default:
12620                                 zend_error(E_WARNING, "Illegal offset type");
12621                                 zval_ptr_dtor(&expr_ptr);
12622                                 /* do nothing */
12623                                 break;
12624                 }
12625 
12626         } else {
12627                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
12628         }
12629         if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
12630 
12631         }
12632         CHECK_EXCEPTION();
12633         ZEND_VM_NEXT_OPCODE();
12634 }
12635 
12636 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12637 {
12638         USE_OPLINE
12639 
12640         array_init(&EX_T(opline->result.var).tmp_var);
12641         if (IS_TMP_VAR == IS_UNUSED) {
12642                 ZEND_VM_NEXT_OPCODE();
12643 #if 0 || IS_TMP_VAR != IS_UNUSED
12644         } else {
12645                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
12646 #endif
12647         }
12648 }
12649 
12650 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12651 {
12652         USE_OPLINE
12653 
12654         /* The generator object is stored in return_value_ptr_ptr */
12655         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
12656 
12657         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
12658                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
12659         }
12660 
12661         /* Destroy the previously yielded value */
12662         if (generator->value) {
12663                 zval_ptr_dtor(&generator->value);
12664         }
12665 
12666         /* Destroy the previously yielded key */
12667         if (generator->key) {
12668                 zval_ptr_dtor(&generator->key);
12669         }
12670 
12671         /* Set the new yielded value */
12672         if (IS_TMP_VAR != IS_UNUSED) {
12673                 zend_free_op free_op1;
12674 
12675                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
12676                         /* Constants and temporary variables aren't yieldable by reference,
12677                          * but we still allow them with a notice. */
12678                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
12679                                 zval *value, *copy;
12680 
12681                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12682 
12683                                 value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12684                                 ALLOC_ZVAL(copy);
12685                                 INIT_PZVAL_COPY(copy, value);
12686 
12687                                 /* Temporary variables don't need ctor copying */
12688                                 if (!1) {
12689                                         zval_copy_ctor(copy);
12690                                 }
12691 
12692                                 generator->value = copy;
12693                         } else {
12694                                 zval **value_ptr = NULL;
12695 
12696                                 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
12697                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
12698                                 }
12699 
12700                                 /* If a function call result is yielded and the function did
12701                                  * not return by reference we throw a notice. */
12702                                 if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
12703                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
12704                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
12705                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
12706                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12707 
12708                                         Z_ADDREF_PP(value_ptr);
12709                                         generator->value = *value_ptr;
12710                                 } else {
12711                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
12712                                         Z_ADDREF_PP(value_ptr);
12713                                         generator->value = *value_ptr;
12714                                 }
12715 
12716                         }
12717                 } else {
12718                         zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12719 
12720                         /* Consts, temporary variables and references need copying */
12721                         if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
12722                                 || PZVAL_IS_REF(value)
12723                         ) {
12724                                 zval *copy;
12725 
12726                                 ALLOC_ZVAL(copy);
12727                                 INIT_PZVAL_COPY(copy, value);
12728 
12729                                 /* Temporary variables don't need ctor copying */
12730                                 if (!1) {
12731                                         zval_copy_ctor(copy);
12732                                 }
12733 
12734                                 generator->value = copy;
12735 
12736                         } else {
12737                                 if (IS_TMP_VAR == IS_CV) {
12738                                         Z_ADDREF_P(value);
12739                                 }
12740                                 generator->value = value;
12741                         }
12742                 }
12743         } else {
12744                 /* If no value was specified yield null */
12745                 Z_ADDREF(EG(uninitialized_zval));
12746                 generator->value = &EG(uninitialized_zval);
12747         }
12748 
12749         /* Set the new yielded key */
12750         if (IS_CV != IS_UNUSED) {
12751 
12752                 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
12753 
12754                 /* Consts, temporary variables and references need copying */
12755                 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
12756                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
12757                 ) {
12758                         zval *copy;
12759 
12760                         ALLOC_ZVAL(copy);
12761                         INIT_PZVAL_COPY(copy, key);
12762 
12763                         /* Temporary variables don't need ctor copying */
12764                         if (!0) {
12765                                 zval_copy_ctor(copy);
12766                         }
12767 
12768                         generator->key = copy;
12769                 } else {
12770                         Z_ADDREF_P(key);
12771                         generator->key = key;
12772                 }
12773 
12774                 if (Z_TYPE_P(generator->key) == IS_LONG
12775                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
12776                 ) {
12777                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
12778                 }
12779 
12780         } else {
12781                 /* If no key was specified we use auto-increment keys */
12782                 generator->largest_used_integer_key++;
12783 
12784                 ALLOC_INIT_ZVAL(generator->key);
12785                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
12786         }
12787 
12788         if (RETURN_VALUE_USED(opline)) {
12789                 /* If the return value of yield is used set the send
12790                  * target and initialize it to NULL */
12791                 generator->send_target = &EX_T(opline->result.var).var.ptr;
12792                 Z_ADDREF(EG(uninitialized_zval));
12793                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
12794         } else {
12795                 generator->send_target = NULL;
12796         }
12797 
12798         /* We increment to the next op, so we are at the correct position when the
12799          * generator is resumed. */
12800         ZEND_VM_INC_OPCODE();
12801 
12802         /* The GOTO VM uses a local opline variable. We need to set the opline
12803          * variable in execute_data so we don't resume at an old position. */
12804         SAVE_OPLINE();
12805 
12806         ZEND_VM_RETURN();
12807 }
12808 
12809 static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12810 {
12811         USE_OPLINE
12812         zend_free_op free_op1;
12813 
12814         SAVE_OPLINE();
12815         pow_function(&EX_T(opline->result.var).tmp_var,
12816                 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
12817                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
12818         zval_dtor(free_op1.var);
12819 
12820         CHECK_EXCEPTION();
12821         ZEND_VM_NEXT_OPCODE();
12822 }
12823 
12824 static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12825 {
12826         USE_OPLINE
12827         zend_free_op free_op1;
12828 
12829         SAVE_OPLINE();
12830         bitwise_not_function(&EX_T(opline->result.var).tmp_var,
12831                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
12832         zval_ptr_dtor_nogc(&free_op1.var);
12833         CHECK_EXCEPTION();
12834         ZEND_VM_NEXT_OPCODE();
12835 }
12836 
12837 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12838 {
12839         USE_OPLINE
12840         zend_free_op free_op1;
12841 
12842         SAVE_OPLINE();
12843         boolean_not_function(&EX_T(opline->result.var).tmp_var,
12844                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
12845         zval_ptr_dtor_nogc(&free_op1.var);
12846         CHECK_EXCEPTION();
12847         ZEND_VM_NEXT_OPCODE();
12848 }
12849 
12850 static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12851 {
12852         USE_OPLINE
12853         zend_free_op free_op1;
12854         zval **var_ptr;
12855 
12856         SAVE_OPLINE();
12857         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12858 
12859         if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
12860                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
12861         }
12862         if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
12863                 if (RETURN_VALUE_USED(opline)) {
12864                         PZVAL_LOCK(&EG(uninitialized_zval));
12865                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
12866                 }
12867                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12868                 CHECK_EXCEPTION();
12869                 ZEND_VM_NEXT_OPCODE();
12870         }
12871 
12872         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
12873 
12874         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
12875            && Z_OBJ_HANDLER_PP(var_ptr, get)
12876            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
12877                 /* proxy object */
12878                 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
12879                 Z_ADDREF_P(val);
12880                 fast_increment_function(val);
12881                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
12882                 zval_ptr_dtor(&val);
12883         } else {
12884                 fast_increment_function(*var_ptr);
12885         }
12886 
12887         if (RETURN_VALUE_USED(opline)) {
12888                 PZVAL_LOCK(*var_ptr);
12889                 EX_T(opline->result.var).var.ptr = *var_ptr;
12890         }
12891 
12892         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12893         CHECK_EXCEPTION();
12894         ZEND_VM_NEXT_OPCODE();
12895 }
12896 
12897 static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12898 {
12899         USE_OPLINE
12900         zend_free_op free_op1;
12901         zval **var_ptr;
12902 
12903         SAVE_OPLINE();
12904         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12905 
12906         if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
12907                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
12908         }
12909         if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
12910                 if (RETURN_VALUE_USED(opline)) {
12911                         PZVAL_LOCK(&EG(uninitialized_zval));
12912                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
12913                 }
12914                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12915                 CHECK_EXCEPTION();
12916                 ZEND_VM_NEXT_OPCODE();
12917         }
12918 
12919         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
12920 
12921         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
12922            && Z_OBJ_HANDLER_PP(var_ptr, get)
12923            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
12924                 /* proxy object */
12925                 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
12926                 Z_ADDREF_P(val);
12927                 fast_decrement_function(val);
12928                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
12929                 zval_ptr_dtor(&val);
12930         } else {
12931                 fast_decrement_function(*var_ptr);
12932         }
12933 
12934         if (RETURN_VALUE_USED(opline)) {
12935                 PZVAL_LOCK(*var_ptr);
12936                 EX_T(opline->result.var).var.ptr = *var_ptr;
12937         }
12938 
12939         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12940         CHECK_EXCEPTION();
12941         ZEND_VM_NEXT_OPCODE();
12942 }
12943 
12944 static int ZEND_FASTCALL  ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12945 {
12946         USE_OPLINE
12947         zend_free_op free_op1;
12948         zval **var_ptr, *retval;
12949 
12950         SAVE_OPLINE();
12951         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12952 
12953         if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
12954                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
12955         }
12956         if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
12957                 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
12958                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12959                 CHECK_EXCEPTION();
12960                 ZEND_VM_NEXT_OPCODE();
12961         }
12962 
12963         retval = &EX_T(opline->result.var).tmp_var;
12964         ZVAL_COPY_VALUE(retval, *var_ptr);
12965         zendi_zval_copy_ctor(*retval);
12966 
12967         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
12968 
12969         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
12970            && Z_OBJ_HANDLER_PP(var_ptr, get)
12971            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
12972                 /* proxy object */
12973                 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
12974                 Z_ADDREF_P(val);
12975                 fast_increment_function(val);
12976                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
12977                 zval_ptr_dtor(&val);
12978         } else {
12979                 fast_increment_function(*var_ptr);
12980         }
12981 
12982         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
12983         CHECK_EXCEPTION();
12984         ZEND_VM_NEXT_OPCODE();
12985 }
12986 
12987 static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12988 {
12989         USE_OPLINE
12990         zend_free_op free_op1;
12991         zval **var_ptr, *retval;
12992 
12993         SAVE_OPLINE();
12994         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
12995 
12996         if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
12997                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
12998         }
12999         if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
13000                 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
13001                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13002                 CHECK_EXCEPTION();
13003                 ZEND_VM_NEXT_OPCODE();
13004         }
13005 
13006         retval = &EX_T(opline->result.var).tmp_var;
13007         ZVAL_COPY_VALUE(retval, *var_ptr);
13008         zendi_zval_copy_ctor(*retval);
13009 
13010         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
13011 
13012         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
13013            && Z_OBJ_HANDLER_PP(var_ptr, get)
13014            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
13015                 /* proxy object */
13016                 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
13017                 Z_ADDREF_P(val);
13018                 fast_decrement_function(val);
13019                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
13020                 zval_ptr_dtor(&val);
13021         } else {
13022                 fast_decrement_function(*var_ptr);
13023         }
13024 
13025         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13026         CHECK_EXCEPTION();
13027         ZEND_VM_NEXT_OPCODE();
13028 }
13029 
13030 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13031 {
13032         USE_OPLINE
13033         zend_free_op free_op1;
13034         zval *z;
13035 
13036         SAVE_OPLINE();
13037         z = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13038 
13039         if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
13040                 INIT_PZVAL(z);
13041         }
13042         zend_print_variable(z);
13043 
13044         zval_ptr_dtor_nogc(&free_op1.var);
13045         CHECK_EXCEPTION();
13046         ZEND_VM_NEXT_OPCODE();
13047 }
13048 
13049 static int ZEND_FASTCALL  ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13050 {
13051         USE_OPLINE
13052 
13053         ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
13054         return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13055 }
13056 
13057 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13058 {
13059         USE_OPLINE
13060         zend_free_op free_op1;
13061         zval *val;
13062         int ret;
13063 
13064         SAVE_OPLINE();
13065         val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13066 
13067         if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13068                 ret = Z_LVAL_P(val);
13069         } else {
13070                 ret = i_zend_is_true(val);
13071                 zval_ptr_dtor_nogc(&free_op1.var);
13072                 if (UNEXPECTED(EG(exception) != NULL)) {
13073                         HANDLE_EXCEPTION();
13074                 }
13075         }
13076         if (!ret) {
13077 #if DEBUG_ZEND>=2
13078                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
13079 #endif
13080                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
13081                 ZEND_VM_CONTINUE();
13082         }
13083 
13084         ZEND_VM_NEXT_OPCODE();
13085 }
13086 
13087 static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13088 {
13089         USE_OPLINE
13090         zend_free_op free_op1;
13091         zval *val;
13092         int ret;
13093 
13094         SAVE_OPLINE();
13095         val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13096 
13097         if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13098                 ret = Z_LVAL_P(val);
13099         } else {
13100                 ret = i_zend_is_true(val);
13101                 zval_ptr_dtor_nogc(&free_op1.var);
13102                 if (UNEXPECTED(EG(exception) != NULL)) {
13103                         HANDLE_EXCEPTION();
13104                 }
13105         }
13106         if (ret) {
13107 #if DEBUG_ZEND>=2
13108                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
13109 #endif
13110                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
13111                 ZEND_VM_CONTINUE();
13112         }
13113 
13114         ZEND_VM_NEXT_OPCODE();
13115 }
13116 
13117 static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13118 {
13119         USE_OPLINE
13120         zend_free_op free_op1;
13121         zval *val;
13122         int retval;
13123 
13124         SAVE_OPLINE();
13125         val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13126 
13127         if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13128                 retval = Z_LVAL_P(val);
13129         } else {
13130                 retval = i_zend_is_true(val);
13131                 zval_ptr_dtor_nogc(&free_op1.var);
13132                 if (UNEXPECTED(EG(exception) != NULL)) {
13133                         HANDLE_EXCEPTION();
13134                 }
13135         }
13136         if (EXPECTED(retval != 0)) {
13137 #if DEBUG_ZEND>=2
13138                 printf("Conditional jmp on true to %d\n", opline->extended_value);
13139 #endif
13140                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
13141                 ZEND_VM_CONTINUE(); /* CHECK_ME */
13142         } else {
13143 #if DEBUG_ZEND>=2
13144                 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
13145 #endif
13146                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
13147                 ZEND_VM_CONTINUE(); /* CHECK_ME */
13148         }
13149 }
13150 
13151 static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13152 {
13153         USE_OPLINE
13154         zend_free_op free_op1;
13155         zval *val;
13156         int retval;
13157 
13158         SAVE_OPLINE();
13159         val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13160 
13161         if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13162                 retval = Z_LVAL_P(val);
13163         } else {
13164                 retval = i_zend_is_true(val);
13165                 zval_ptr_dtor_nogc(&free_op1.var);
13166                 if (UNEXPECTED(EG(exception) != NULL)) {
13167                         HANDLE_EXCEPTION();
13168                 }
13169         }
13170         Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
13171         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
13172         if (!retval) {
13173 #if DEBUG_ZEND>=2
13174                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
13175 #endif
13176                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
13177                 ZEND_VM_CONTINUE();
13178         }
13179         ZEND_VM_NEXT_OPCODE();
13180 }
13181 
13182 static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13183 {
13184         USE_OPLINE
13185         zend_free_op free_op1;
13186         zval *val;
13187         int retval;
13188 
13189         SAVE_OPLINE();
13190         val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13191 
13192         if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
13193                 retval = Z_LVAL_P(val);
13194         } else {
13195                 retval = i_zend_is_true(val);
13196                 zval_ptr_dtor_nogc(&free_op1.var);
13197                 if (UNEXPECTED(EG(exception) != NULL)) {
13198                         HANDLE_EXCEPTION();
13199                 }
13200         }
13201         Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
13202         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
13203         if (retval) {
13204 #if DEBUG_ZEND>=2
13205                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
13206 #endif
13207                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
13208                 ZEND_VM_CONTINUE();
13209         }
13210         ZEND_VM_NEXT_OPCODE();
13211 }
13212 
13213 static int ZEND_FASTCALL  ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13214 {
13215         USE_OPLINE
13216 
13217         SAVE_OPLINE();
13218         if (IS_VAR == IS_TMP_VAR) {
13219                 zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
13220         } else {
13221                 zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
13222         }
13223         CHECK_EXCEPTION();
13224         ZEND_VM_NEXT_OPCODE();
13225 }
13226 
13227 static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13228 {
13229         USE_OPLINE
13230         zval *retval_ptr;
13231         zend_free_op free_op1;
13232 
13233         SAVE_OPLINE();
13234         retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13235 
13236         if (!EG(return_value_ptr_ptr)) {
13237                 zval_ptr_dtor_nogc(&free_op1.var);
13238         } else {
13239                 if (IS_VAR == IS_CONST ||
13240                     IS_VAR == IS_TMP_VAR ||
13241                     PZVAL_IS_REF(retval_ptr)) {
13242                         zval *ret;
13243 
13244                         ALLOC_ZVAL(ret);
13245                         INIT_PZVAL_COPY(ret, retval_ptr);
13246                         if (IS_VAR != IS_TMP_VAR) {
13247                                 zval_copy_ctor(ret);
13248                         }
13249                         *EG(return_value_ptr_ptr) = ret;
13250                         zval_ptr_dtor_nogc(&free_op1.var);
13251                 } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
13252                            retval_ptr == &EG(uninitialized_zval)) {
13253                         zval *ret;
13254 
13255                         if (IS_VAR == IS_VAR) {
13256                                 Z_DELREF_P(retval_ptr);
13257                         }
13258                         ALLOC_INIT_ZVAL(ret);
13259                         *EG(return_value_ptr_ptr) = ret;
13260                 } else {
13261                         *EG(return_value_ptr_ptr) = retval_ptr;
13262                         if (IS_VAR == IS_CV) {
13263                                 Z_ADDREF_P(retval_ptr);
13264                         }
13265                 }
13266         }
13267         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13268 }
13269 
13270 static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13271 {
13272         USE_OPLINE
13273         zval *retval_ptr;
13274         zval **retval_ptr_ptr;
13275         zend_free_op free_op1;
13276 
13277         SAVE_OPLINE();
13278 
13279         do {
13280                 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR ||
13281                     (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
13282                         /* Not supposed to happen, but we'll allow it */
13283                         zend_error(E_NOTICE, "Only variable references should be returned by reference");
13284 
13285                         retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13286                         if (!EG(return_value_ptr_ptr)) {
13287                                 if (IS_VAR == IS_TMP_VAR) {
13288                                         zval_ptr_dtor_nogc(&free_op1.var);
13289                                 }
13290                         } else if (!0) { /* Not a temp var */
13291                                 zval *ret;
13292 
13293                                 ALLOC_ZVAL(ret);
13294                                 INIT_PZVAL_COPY(ret, retval_ptr);
13295                                 zval_copy_ctor(ret);
13296                                 *EG(return_value_ptr_ptr) = ret;
13297                         } else {
13298                                 zval *ret;
13299 
13300                                 ALLOC_ZVAL(ret);
13301                                 INIT_PZVAL_COPY(ret, retval_ptr);
13302                                 *EG(return_value_ptr_ptr) = ret;
13303                         }
13304                         break;
13305                 }
13306 
13307                 retval_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13308 
13309                 if (IS_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
13310                         zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
13311                 }
13312 
13313                 if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
13314                         if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
13315                             EX_T(opline->op1.var).var.fcall_returned_reference) {
13316                         } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
13317                                 zend_error(E_NOTICE, "Only variable references should be returned by reference");
13318                                 if (EG(return_value_ptr_ptr)) {
13319                                         zval *ret;
13320 
13321                                         ALLOC_ZVAL(ret);
13322                                         INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
13323                                         zval_copy_ctor(ret);
13324                                         *EG(return_value_ptr_ptr) = ret;
13325                                 }
13326                                 break;
13327                         }
13328                 }
13329 
13330                 if (EG(return_value_ptr_ptr)) {
13331                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
13332                         Z_ADDREF_PP(retval_ptr_ptr);
13333 
13334                         *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
13335                 }
13336         } while (0);
13337 
13338         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13339         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13340 }
13341 
13342 static int ZEND_FASTCALL  ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13343 {
13344         USE_OPLINE
13345         zval *value;
13346         zval *exception;
13347         zend_free_op free_op1;
13348 
13349         SAVE_OPLINE();
13350         value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13351 
13352         if (IS_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
13353                 if (UNEXPECTED(EG(exception) != NULL)) {
13354                         HANDLE_EXCEPTION();
13355                 }
13356                 zend_error_noreturn(E_ERROR, "Can only throw objects");
13357         }
13358 
13359         zend_exception_save(TSRMLS_C);
13360         /* Not sure if a complete copy is what we want here */
13361         ALLOC_ZVAL(exception);
13362         INIT_PZVAL_COPY(exception, value);
13363         if (!0) {
13364                 zval_copy_ctor(exception);
13365         }
13366 
13367         zend_throw_exception_object(exception TSRMLS_CC);
13368         zend_exception_restore(TSRMLS_C);
13369         zval_ptr_dtor_nogc(&free_op1.var);
13370         HANDLE_EXCEPTION();
13371 }
13372 
13373 static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
13374 {
13375         USE_OPLINE
13376         zval *varptr;
13377         zend_free_op free_op1;
13378         varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13379 
13380         if (varptr == &EG(uninitialized_zval)) {
13381                 if (IS_VAR == IS_VAR) {
13382                         Z_DELREF_P(varptr);
13383                 }
13384                 ALLOC_INIT_ZVAL(varptr);
13385         } else if (PZVAL_IS_REF(varptr)) {
13386                 if (IS_VAR == IS_CV ||
13387                     (IS_VAR == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
13388                         zval *original_var = varptr;
13389 
13390                         ALLOC_ZVAL(varptr);
13391                         INIT_PZVAL_COPY(varptr, original_var);
13392                         zval_copy_ctor(varptr);
13393                         zval_ptr_dtor_nogc(&free_op1.var);
13394                 } else {
13395                         Z_UNSET_ISREF_P(varptr);
13396                 }
13397         } else if (IS_VAR == IS_CV) {
13398                 Z_ADDREF_P(varptr);
13399         }
13400         zend_vm_stack_push(varptr TSRMLS_CC);
13401 
13402         CHECK_EXCEPTION();
13403         ZEND_VM_NEXT_OPCODE();
13404 }
13405 
13406 static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13407 {
13408         USE_OPLINE
13409         zend_free_op free_op1;
13410         zval *varptr;
13411 
13412         SAVE_OPLINE();
13413         if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
13414                 if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
13415                         return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13416                 }
13417         } else {
13418                 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
13419                         return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13420                 }
13421         }
13422 
13423         varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13424         if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
13425              EX_T(opline->op1.var).var.fcall_returned_reference) &&
13426             varptr != &EG(uninitialized_zval) &&
13427             (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) {
13428                 Z_SET_ISREF_P(varptr);
13429                 if (IS_VAR == IS_CV) {
13430                         Z_ADDREF_P(varptr);
13431                 }
13432                 zend_vm_stack_push(varptr TSRMLS_CC);
13433         } else {
13434                 zval *valptr;
13435 
13436                 if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
13437                         !(opline->extended_value & ZEND_ARG_SEND_SILENT) :
13438                         !ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
13439                         zend_error(E_STRICT, "Only variables should be passed by reference");
13440                 }
13441                 ALLOC_ZVAL(valptr);
13442                 INIT_PZVAL_COPY(valptr, varptr);
13443                 if (!0) {
13444                         zval_copy_ctor(valptr);
13445                 }
13446                 zval_ptr_dtor_nogc(&free_op1.var);
13447                 zend_vm_stack_push(valptr TSRMLS_CC);
13448         }
13449         CHECK_EXCEPTION();
13450         ZEND_VM_NEXT_OPCODE();
13451 }
13452 
13453 static int ZEND_FASTCALL  ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13454 {
13455         USE_OPLINE
13456         zend_free_op free_op1;
13457         zval **varptr_ptr;
13458         zval *varptr;
13459 
13460         SAVE_OPLINE();
13461         varptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13462 
13463         if (IS_VAR == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) {
13464                 zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
13465         }
13466 
13467         if (IS_VAR == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) {
13468                 ALLOC_INIT_ZVAL(varptr);
13469                 zend_vm_stack_push(varptr TSRMLS_CC);
13470                 CHECK_EXCEPTION();
13471                 ZEND_VM_NEXT_OPCODE();
13472         }
13473 
13474         if (opline->extended_value == ZEND_DO_FCALL_BY_NAME &&
13475             EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
13476                 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
13477                         return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13478                 }
13479         }
13480 
13481         SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
13482         varptr = *varptr_ptr;
13483         Z_ADDREF_P(varptr);
13484         zend_vm_stack_push(varptr TSRMLS_CC);
13485 
13486         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13487         CHECK_EXCEPTION();
13488         ZEND_VM_NEXT_OPCODE();
13489 }
13490 
13491 static int ZEND_FASTCALL  ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13492 {
13493         USE_OPLINE
13494 
13495         if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
13496                 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
13497                         return ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13498                 }
13499         }
13500         SAVE_OPLINE();
13501         return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
13502 }
13503 
13504 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13505 {
13506         USE_OPLINE
13507         zend_free_op free_op1;
13508         zval *retval = &EX_T(opline->result.var).tmp_var;
13509 
13510         SAVE_OPLINE();
13511         /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
13512         ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)));
13513         zval_ptr_dtor_nogc(&free_op1.var);
13514 
13515         CHECK_EXCEPTION();
13516         ZEND_VM_NEXT_OPCODE();
13517 }
13518 
13519 static int ZEND_FASTCALL  ZEND_SWITCH_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13520 {
13521         USE_OPLINE
13522 
13523         SAVE_OPLINE();
13524         zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
13525         CHECK_EXCEPTION();
13526         ZEND_VM_NEXT_OPCODE();
13527 }
13528 
13529 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13530 {
13531         USE_OPLINE
13532         zend_free_op free_op1;
13533         zval *obj;
13534         zend_class_entry *ce;
13535         zend_function *clone;
13536         zend_object_clone_obj_t clone_call;
13537 
13538         SAVE_OPLINE();
13539         obj = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13540 
13541         if (IS_VAR == IS_CONST ||
13542             UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
13543                 if (UNEXPECTED(EG(exception) != NULL)) {
13544                         HANDLE_EXCEPTION();
13545                 }
13546                 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
13547         }
13548 
13549         ce = Z_OBJCE_P(obj);
13550         clone = ce ? ce->clone : NULL;
13551         clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
13552         if (UNEXPECTED(clone_call == NULL)) {
13553                 if (ce) {
13554                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
13555                 } else {
13556                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
13557                 }
13558         }
13559 
13560         if (ce && clone) {
13561                 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
13562                         /* Ensure that if we're calling a private function, we're allowed to do so.
13563                          */
13564                         if (UNEXPECTED(ce != EG(scope))) {
13565                                 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
13566                         }
13567                 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
13568                         /* Ensure that if we're calling a protected function, we're allowed to do so.
13569                          */
13570                         if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
13571                                 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
13572                         }
13573                 }
13574         }
13575 
13576         if (EXPECTED(EG(exception) == NULL)) {
13577                 zval *retval;
13578 
13579                 ALLOC_ZVAL(retval);
13580                 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
13581                 Z_TYPE_P(retval) = IS_OBJECT;
13582                 Z_SET_REFCOUNT_P(retval, 1);
13583                 Z_SET_ISREF_P(retval);
13584                 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
13585                         zval_ptr_dtor(&retval);
13586                 } else {
13587                         EX_T(opline->result.var).var.ptr = retval;
13588                 }
13589         }
13590         zval_ptr_dtor_nogc(&free_op1.var);
13591         CHECK_EXCEPTION();
13592         ZEND_VM_NEXT_OPCODE();
13593 }
13594 
13595 static int ZEND_FASTCALL  ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13596 {
13597         USE_OPLINE
13598         zend_free_op free_op1;
13599         zval *expr;
13600         zval *result = &EX_T(opline->result.var).tmp_var;
13601 
13602         SAVE_OPLINE();
13603         expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13604 
13605         if (opline->extended_value != IS_STRING) {
13606                 ZVAL_COPY_VALUE(result, expr);
13607                 if (!0) {
13608                         zendi_zval_copy_ctor(*result);
13609                 }
13610         }
13611         switch (opline->extended_value) {
13612                 case IS_NULL:
13613                         convert_to_null(result);
13614                         break;
13615                 case IS_BOOL:
13616                         convert_to_boolean(result);
13617                         break;
13618                 case IS_LONG:
13619                         convert_to_long(result);
13620                         break;
13621                 case IS_DOUBLE:
13622                         convert_to_double(result);
13623                         break;
13624                 case IS_STRING: {
13625                         zval var_copy;
13626                         int use_copy;
13627 
13628                         zend_make_printable_zval(expr, &var_copy, &use_copy);
13629                         if (use_copy) {
13630                                 ZVAL_COPY_VALUE(result, &var_copy);
13631                                 if (0) {
13632                                         zval_ptr_dtor_nogc(&free_op1.var);
13633                                 }
13634                         } else {
13635                                 ZVAL_COPY_VALUE(result, expr);
13636                                 if (!0) {
13637                                         zendi_zval_copy_ctor(*result);
13638                                 }
13639                         }
13640                         break;
13641                 }
13642                 case IS_ARRAY:
13643                         convert_to_array(result);
13644                         break;
13645                 case IS_OBJECT:
13646                         convert_to_object(result);
13647                         break;
13648         }
13649         zval_ptr_dtor_nogc(&free_op1.var);
13650         CHECK_EXCEPTION();
13651         ZEND_VM_NEXT_OPCODE();
13652 }
13653 
13654 static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13655 {
13656         USE_OPLINE
13657         zend_op_array *new_op_array=NULL;
13658         zend_free_op free_op1;
13659         zval *inc_filename;
13660         zval *tmp_inc_filename = NULL;
13661         zend_bool failure_retval=0;
13662 
13663         SAVE_OPLINE();
13664         inc_filename = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13665 
13666         if (inc_filename->type!=IS_STRING) {
13667                 MAKE_STD_ZVAL(tmp_inc_filename);
13668                 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
13669                 zval_copy_ctor(tmp_inc_filename);
13670                 convert_to_string(tmp_inc_filename);
13671                 inc_filename = tmp_inc_filename;
13672         }
13673 
13674         if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
13675                 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
13676                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
13677                 } else {
13678                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
13679                 }
13680         } else {
13681                 switch (opline->extended_value) {
13682                         case ZEND_INCLUDE_ONCE:
13683                         case ZEND_REQUIRE_ONCE: {
13684                                         zend_file_handle file_handle;
13685                                         char *resolved_path;
13686 
13687                                         resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
13688                                         if (resolved_path) {
13689                                                 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
13690                                         } else {
13691                                                 resolved_path = Z_STRVAL_P(inc_filename);
13692                                         }
13693 
13694                                         if (failure_retval) {
13695                                                 /* do nothing, file already included */
13696                                         } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
13697 
13698                                                 if (!file_handle.opened_path) {
13699                                                         file_handle.opened_path = estrdup(resolved_path);
13700                                                 }
13701 
13702                                                 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
13703                                                         new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
13704                                                         zend_destroy_file_handle(&file_handle TSRMLS_CC);
13705                                                 } else {
13706                                                         zend_file_handle_dtor(&file_handle TSRMLS_CC);
13707                                                         failure_retval=1;
13708                                                 }
13709                                         } else {
13710                                                 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
13711                                                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
13712                                                 } else {
13713                                                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
13714                                                 }
13715                                         }
13716                                         if (resolved_path != Z_STRVAL_P(inc_filename)) {
13717                                                 efree(resolved_path);
13718                                         }
13719                                 }
13720                                 break;
13721                         case ZEND_INCLUDE:
13722                         case ZEND_REQUIRE:
13723                                 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
13724                                 break;
13725                         case ZEND_EVAL: {
13726                                         char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
13727 
13728                                         new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
13729                                         efree(eval_desc);
13730                                 }
13731                                 break;
13732                         EMPTY_SWITCH_DEFAULT_CASE()
13733                 }
13734         }
13735         if (tmp_inc_filename) {
13736                 zval_ptr_dtor(&tmp_inc_filename);
13737         }
13738         zval_ptr_dtor_nogc(&free_op1.var);
13739         if (UNEXPECTED(EG(exception) != NULL)) {
13740                 HANDLE_EXCEPTION();
13741         } else if (EXPECTED(new_op_array != NULL)) {
13742                 EX(original_return_value) = EG(return_value_ptr_ptr);
13743                 EG(active_op_array) = new_op_array;
13744                 if (RETURN_VALUE_USED(opline)) {
13745                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
13746                         EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
13747                 } else {
13748                         EG(return_value_ptr_ptr) = NULL;
13749                 }
13750 
13751                 EX(function_state).function = (zend_function *) new_op_array;
13752                 EX(object) = NULL;
13753 
13754                 if (!EG(active_symbol_table)) {
13755                         zend_rebuild_symbol_table(TSRMLS_C);
13756                 }
13757 
13758                 if (EXPECTED(zend_execute_ex == execute_ex)) {
13759                         ZEND_VM_ENTER();
13760                 } else {
13761                         zend_execute(new_op_array TSRMLS_CC);
13762                 }
13763 
13764                 EX(function_state).function = (zend_function *) EX(op_array);
13765 
13766                 EG(opline_ptr) = &EX(opline);
13767                 EG(active_op_array) = EX(op_array);
13768                 EG(return_value_ptr_ptr) = EX(original_return_value);
13769                 destroy_op_array(new_op_array TSRMLS_CC);
13770                 efree(new_op_array);
13771                 if (UNEXPECTED(EG(exception) != NULL)) {
13772                         zend_throw_exception_internal(NULL TSRMLS_CC);
13773                         HANDLE_EXCEPTION();
13774                 }
13775 
13776         } else if (RETURN_VALUE_USED(opline)) {
13777                 zval *retval;
13778 
13779                 ALLOC_ZVAL(retval);
13780                 ZVAL_BOOL(retval, failure_retval);
13781                 INIT_PZVAL(retval);
13782                 EX_T(opline->result.var).var.ptr = retval;
13783         }
13784         ZEND_VM_NEXT_OPCODE();
13785 }
13786 
13787 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13788 {
13789         USE_OPLINE
13790         zend_free_op free_op1;
13791         zval *array_ptr, **array_ptr_ptr;
13792         HashTable *fe_ht;
13793         zend_object_iterator *iter = NULL;
13794         zend_class_entry *ce = NULL;
13795         zend_bool is_empty = 0;
13796 
13797         SAVE_OPLINE();
13798 
13799         if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
13800             (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
13801                 array_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13802                 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
13803                         MAKE_STD_ZVAL(array_ptr);
13804                         ZVAL_NULL(array_ptr);
13805                 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
13806                         if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
13807                                 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
13808                                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
13809                         }
13810 
13811                         ce = Z_OBJCE_PP(array_ptr_ptr);
13812                         if (!ce || ce->get_iterator == NULL) {
13813                                 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
13814                                 Z_ADDREF_PP(array_ptr_ptr);
13815                         }
13816                         array_ptr = *array_ptr_ptr;
13817                 } else {
13818                         if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
13819                                 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
13820                                 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
13821                                         Z_SET_ISREF_PP(array_ptr_ptr);
13822                                 }
13823                         }
13824                         array_ptr = *array_ptr_ptr;
13825                         Z_ADDREF_P(array_ptr);
13826                 }
13827         } else {
13828                 array_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
13829                 if (0) { /* IS_TMP_VAR */
13830                         zval *tmp;
13831 
13832                         ALLOC_ZVAL(tmp);
13833                         INIT_PZVAL_COPY(tmp, array_ptr);
13834                         array_ptr = tmp;
13835                         if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
13836                                 ce = Z_OBJCE_P(array_ptr);
13837                                 if (ce && ce->get_iterator) {
13838                                         Z_DELREF_P(array_ptr);
13839                                 }
13840                         }
13841                 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
13842                         ce = Z_OBJCE_P(array_ptr);
13843                         if (!ce || !ce->get_iterator) {
13844                                 if (IS_VAR == IS_CV) {
13845                                         Z_ADDREF_P(array_ptr);
13846                                 }
13847                         }
13848                 } else if (IS_VAR == IS_CONST ||
13849                            (IS_VAR == IS_CV &&
13850                             !Z_ISREF_P(array_ptr) &&
13851                             Z_REFCOUNT_P(array_ptr) > 1) ||
13852                            (IS_VAR == IS_VAR &&
13853                             !Z_ISREF_P(array_ptr) &&
13854                             Z_REFCOUNT_P(array_ptr) > 2)) {
13855                         zval *tmp;
13856 
13857                         if (IS_VAR == IS_VAR) {
13858                                 Z_DELREF_P(array_ptr);
13859                         }
13860                         ALLOC_ZVAL(tmp);
13861                         INIT_PZVAL_COPY(tmp, array_ptr);
13862                         zval_copy_ctor(tmp);
13863                         array_ptr = tmp;
13864                 } else if (IS_VAR == IS_CV) {
13865                         Z_ADDREF_P(array_ptr);
13866                 }
13867         }
13868 
13869         if (ce && ce->get_iterator) {
13870                 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
13871 
13872                 if (IS_VAR == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
13873                         zval_ptr_dtor_nogc(&free_op1.var);
13874                 }
13875                 if (iter && EXPECTED(EG(exception) == NULL)) {
13876                         array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
13877                 } else {
13878                         if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
13879                                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13880                         }
13881                         if (!EG(exception)) {
13882                                 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
13883                         }
13884                         zend_throw_exception_internal(NULL TSRMLS_CC);
13885                         HANDLE_EXCEPTION();
13886                 }
13887         }
13888 
13889         EX_T(opline->result.var).fe.ptr = array_ptr;
13890 
13891         if (iter) {
13892                 iter->index = 0;
13893                 if (iter->funcs->rewind) {
13894                         iter->funcs->rewind(iter TSRMLS_CC);
13895                         if (UNEXPECTED(EG(exception) != NULL)) {
13896                                 zval_ptr_dtor(&array_ptr);
13897                                 if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
13898                                         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13899                                 }
13900                                 HANDLE_EXCEPTION();
13901                         }
13902                 }
13903                 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
13904                 if (UNEXPECTED(EG(exception) != NULL)) {
13905                         zval_ptr_dtor(&array_ptr);
13906                         if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
13907                                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13908                         }
13909                         HANDLE_EXCEPTION();
13910                 }
13911                 iter->index = -1; /* will be set to 0 before using next handler */
13912         } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
13913                 zend_hash_internal_pointer_reset(fe_ht);
13914                 if (ce) {
13915                         zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
13916                         while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
13917                                 char *str_key;
13918                                 uint str_key_len;
13919                                 ulong int_key;
13920                                 zend_uchar key_type;
13921 
13922                                 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
13923                                 if (key_type != HASH_KEY_NON_EXISTENT &&
13924                                         (key_type == HASH_KEY_IS_LONG ||
13925                                      zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
13926                                         break;
13927                                 }
13928                                 zend_hash_move_forward(fe_ht);
13929                         }
13930                 }
13931                 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
13932                 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
13933         } else {
13934                 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
13935                 is_empty = 1;
13936         }
13937 
13938         if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
13939                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
13940         }
13941         if (is_empty) {
13942                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
13943         } else {
13944                 CHECK_EXCEPTION();
13945                 ZEND_VM_NEXT_OPCODE();
13946         }
13947 }
13948 
13949 static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13950 {
13951         USE_OPLINE
13952 
13953         zval *array = EX_T(opline->op1.var).fe.ptr;
13954         zval **value;
13955         HashTable *fe_ht;
13956         zend_object_iterator *iter = NULL;
13957 
13958         zval *key = NULL;
13959         if (opline->extended_value & ZEND_FE_FETCH_WITH_KEY) {
13960                 key = &EX_T((opline+1)->result.var).tmp_var;
13961         }
13962 
13963         SAVE_OPLINE();
13964 
13965         switch (zend_iterator_unwrap(array, &iter TSRMLS_CC)) {
13966                 default:
13967                 case ZEND_ITER_INVALID:
13968                         zend_error(E_WARNING, "Invalid argument supplied for foreach()");
13969                         ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
13970 
13971                 case ZEND_ITER_PLAIN_OBJECT: {
13972                         zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
13973                         int key_type;
13974                         char *str_key;
13975                         zend_uint str_key_len;
13976                         zend_ulong int_key;
13977 
13978                         fe_ht = Z_OBJPROP_P(array);
13979                         zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
13980                         do {
13981                                 if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
13982                                         /* reached end of iteration */
13983                                         ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
13984                                 }
13985                                 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
13986 
13987                                 zend_hash_move_forward(fe_ht);
13988                         } while (key_type != HASH_KEY_IS_LONG &&
13989                                  zend_check_property_access(zobj, str_key, str_key_len - 1 TSRMLS_CC) != SUCCESS);
13990 
13991                         if (key) {
13992                                 if (key_type == HASH_KEY_IS_LONG) {
13993                                         ZVAL_LONG(key, int_key);
13994                                 } else {
13995                                         const char *class_name, *prop_name;
13996                                         int prop_name_len;
13997                                         zend_unmangle_property_name_ex(
13998                                                 str_key, str_key_len - 1, &class_name, &prop_name, &prop_name_len
13999                                         );
14000                                         ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
14001                                 }
14002                         }
14003 
14004                         zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
14005                         break;
14006                 }
14007 
14008                 case ZEND_ITER_PLAIN_ARRAY:
14009                         fe_ht = Z_ARRVAL_P(array);
14010                         zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
14011                         if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
14012                                 /* reached end of iteration */
14013                                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
14014                         }
14015                         if (key) {
14016                                 zend_hash_get_current_key_zval(fe_ht, key);
14017                         }
14018                         zend_hash_move_forward(fe_ht);
14019                         zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
14020                         break;
14021 
14022                 case ZEND_ITER_OBJECT:
14023                         /* !iter happens from exception */
14024                         if (iter && ++iter->index > 0) {
14025                                 /* This could cause an endless loop if index becomes zero again.
14026                                  * In case that ever happens we need an additional flag. */
14027                                 iter->funcs->move_forward(iter TSRMLS_CC);
14028                                 if (UNEXPECTED(EG(exception) != NULL)) {
14029                                         zval_ptr_dtor(&array);
14030                                         HANDLE_EXCEPTION();
14031                                 }
14032                         }
14033                         /* If index is zero we come from FE_RESET and checked valid() already. */
14034                         if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
14035                                 /* reached end of iteration */
14036                                 if (UNEXPECTED(EG(exception) != NULL)) {
14037                                         zval_ptr_dtor(&array);
14038                                         HANDLE_EXCEPTION();
14039                                 }
14040                                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
14041                         }
14042                         iter->funcs->get_current_data(iter, &value TSRMLS_CC);
14043                         if (UNEXPECTED(EG(exception) != NULL)) {
14044                                 zval_ptr_dtor(&array);
14045                                 HANDLE_EXCEPTION();
14046                         }
14047                         if (!value) {
14048                                 /* failure in get_current_data */
14049                                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
14050                         }
14051                         if (key) {
14052                                 if (iter->funcs->get_current_key) {
14053                                         iter->funcs->get_current_key(iter, key TSRMLS_CC);
14054                                         if (UNEXPECTED(EG(exception) != NULL)) {
14055                                                 zval_ptr_dtor(&array);
14056                                                 HANDLE_EXCEPTION();
14057                                         }
14058                                 } else {
14059                                         ZVAL_LONG(key, iter->index);
14060                                 }
14061                         }
14062                         break;
14063         }
14064 
14065         if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
14066                 SEPARATE_ZVAL_IF_NOT_REF(value);
14067                 Z_SET_ISREF_PP(value);
14068                 EX_T(opline->result.var).var.ptr_ptr = value;
14069                 Z_ADDREF_PP(value);
14070         } else {
14071                 PZVAL_LOCK(*value);
14072                 EX_T(opline->result.var).var.ptr = *value;
14073         }
14074 
14075         CHECK_EXCEPTION();
14076         ZEND_VM_INC_OPCODE();
14077         ZEND_VM_NEXT_OPCODE();
14078 }
14079 
14080 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14081 {
14082 #if 0 || (IS_VAR != IS_UNUSED)
14083         USE_OPLINE
14084 
14085         SAVE_OPLINE();
14086         if (IS_VAR != IS_UNUSED) {
14087                 zend_free_op free_op1;
14088                 zval *ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14089 
14090                 if (Z_TYPE_P(ptr) == IS_LONG) {
14091                         EG(exit_status) = Z_LVAL_P(ptr);
14092                 } else {
14093                         zend_print_variable(ptr);
14094                 }
14095                 zval_ptr_dtor_nogc(&free_op1.var);
14096         }
14097 #endif
14098         zend_bailout();
14099         ZEND_VM_NEXT_OPCODE(); /* Never reached */
14100 }
14101 
14102 static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14103 {
14104         USE_OPLINE
14105         zend_free_op free_op1;
14106         zval *value;
14107 
14108         SAVE_OPLINE();
14109         value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14110 
14111         if (i_zend_is_true(value)) {
14112                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
14113                 if (!0) {
14114                         zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
14115                 }
14116                 zval_ptr_dtor_nogc(&free_op1.var);
14117 #if DEBUG_ZEND>=2
14118                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
14119 #endif
14120                 ZEND_VM_JMP(opline->op2.jmp_addr);
14121         }
14122 
14123         zval_ptr_dtor_nogc(&free_op1.var);
14124         CHECK_EXCEPTION();
14125         ZEND_VM_NEXT_OPCODE();
14126 }
14127 
14128 static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14129 {
14130         USE_OPLINE
14131         zend_free_op free_op1;
14132         zval *value, *ret;
14133 
14134         SAVE_OPLINE();
14135         value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14136 
14137         if (i_zend_is_true(value)) {
14138                 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
14139                         Z_ADDREF_P(value);
14140                         EX_T(opline->result.var).var.ptr = value;
14141                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
14142                 } else {
14143                         ALLOC_ZVAL(ret);
14144                         INIT_PZVAL_COPY(ret, value);
14145                         EX_T(opline->result.var).var.ptr = ret;
14146                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
14147                         if (!0) {
14148                                 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
14149                         }
14150                 }
14151                 zval_ptr_dtor_nogc(&free_op1.var);
14152 #if DEBUG_ZEND>=2
14153                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
14154 #endif
14155                 ZEND_VM_JMP(opline->op2.jmp_addr);
14156         }
14157 
14158         zval_ptr_dtor_nogc(&free_op1.var);
14159         CHECK_EXCEPTION();
14160         ZEND_VM_NEXT_OPCODE();
14161 }
14162 
14163 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14164 {
14165         USE_OPLINE
14166         zend_free_op free_op1;
14167         zval *value;
14168 
14169         SAVE_OPLINE();
14170         value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14171 
14172         ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
14173         if (!0) {
14174                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
14175         }
14176         zval_ptr_dtor_nogc(&free_op1.var);
14177         CHECK_EXCEPTION();
14178         ZEND_VM_NEXT_OPCODE();
14179 }
14180 
14181 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14182 {
14183         USE_OPLINE
14184         zend_free_op free_op1;
14185         zval *value, *ret;
14186 
14187         SAVE_OPLINE();
14188         value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14189 
14190         if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
14191                 Z_ADDREF_P(value);
14192                 EX_T(opline->result.var).var.ptr = value;
14193                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
14194         } else {
14195                 ALLOC_ZVAL(ret);
14196                 INIT_PZVAL_COPY(ret, value);
14197                 EX_T(opline->result.var).var.ptr = ret;
14198                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
14199                 if (!0) {
14200                         zval_copy_ctor(EX_T(opline->result.var).var.ptr);
14201                 }
14202         }
14203 
14204         zval_ptr_dtor_nogc(&free_op1.var);
14205         CHECK_EXCEPTION();
14206         ZEND_VM_NEXT_OPCODE();
14207 }
14208 
14209 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14210 {
14211         USE_OPLINE
14212         zend_free_op free_op1;
14213         zval *expr;
14214         zend_bool result;
14215 
14216         SAVE_OPLINE();
14217         expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14218 
14219         if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
14220                 result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
14221         } else {
14222                 result = 0;
14223         }
14224         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
14225         zval_ptr_dtor_nogc(&free_op1.var);
14226         CHECK_EXCEPTION();
14227         ZEND_VM_NEXT_OPCODE();
14228 }
14229 
14230 static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14231 {
14232         USE_OPLINE
14233         zend_free_op free_op1;
14234 
14235         SAVE_OPLINE();
14236         fast_add_function(&EX_T(opline->result.var).tmp_var,
14237                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14238                 opline->op2.zv TSRMLS_CC);
14239         zval_ptr_dtor_nogc(&free_op1.var);
14240 
14241         CHECK_EXCEPTION();
14242         ZEND_VM_NEXT_OPCODE();
14243 }
14244 
14245 static int ZEND_FASTCALL  ZEND_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14246 {
14247         USE_OPLINE
14248         zend_free_op free_op1;
14249 
14250         SAVE_OPLINE();
14251         fast_sub_function(&EX_T(opline->result.var).tmp_var,
14252                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14253                 opline->op2.zv TSRMLS_CC);
14254         zval_ptr_dtor_nogc(&free_op1.var);
14255 
14256         CHECK_EXCEPTION();
14257         ZEND_VM_NEXT_OPCODE();
14258 }
14259 
14260 static int ZEND_FASTCALL  ZEND_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14261 {
14262         USE_OPLINE
14263         zend_free_op free_op1;
14264 
14265         SAVE_OPLINE();
14266         fast_mul_function(&EX_T(opline->result.var).tmp_var,
14267                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14268                 opline->op2.zv TSRMLS_CC);
14269         zval_ptr_dtor_nogc(&free_op1.var);
14270 
14271         CHECK_EXCEPTION();
14272         ZEND_VM_NEXT_OPCODE();
14273 }
14274 
14275 static int ZEND_FASTCALL  ZEND_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14276 {
14277         USE_OPLINE
14278         zend_free_op free_op1;
14279 
14280         SAVE_OPLINE();
14281         fast_div_function(&EX_T(opline->result.var).tmp_var,
14282                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14283                 opline->op2.zv TSRMLS_CC);
14284         zval_ptr_dtor_nogc(&free_op1.var);
14285 
14286         CHECK_EXCEPTION();
14287         ZEND_VM_NEXT_OPCODE();
14288 }
14289 
14290 static int ZEND_FASTCALL  ZEND_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14291 {
14292         USE_OPLINE
14293         zend_free_op free_op1;
14294 
14295         SAVE_OPLINE();
14296         fast_mod_function(&EX_T(opline->result.var).tmp_var,
14297                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14298                 opline->op2.zv TSRMLS_CC);
14299         zval_ptr_dtor_nogc(&free_op1.var);
14300 
14301         CHECK_EXCEPTION();
14302         ZEND_VM_NEXT_OPCODE();
14303 }
14304 
14305 static int ZEND_FASTCALL  ZEND_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14306 {
14307         USE_OPLINE
14308         zend_free_op free_op1;
14309 
14310         SAVE_OPLINE();
14311         shift_left_function(&EX_T(opline->result.var).tmp_var,
14312                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14313                 opline->op2.zv TSRMLS_CC);
14314         zval_ptr_dtor_nogc(&free_op1.var);
14315 
14316         CHECK_EXCEPTION();
14317         ZEND_VM_NEXT_OPCODE();
14318 }
14319 
14320 static int ZEND_FASTCALL  ZEND_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14321 {
14322         USE_OPLINE
14323         zend_free_op free_op1;
14324 
14325         SAVE_OPLINE();
14326         shift_right_function(&EX_T(opline->result.var).tmp_var,
14327                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14328                 opline->op2.zv TSRMLS_CC);
14329         zval_ptr_dtor_nogc(&free_op1.var);
14330 
14331         CHECK_EXCEPTION();
14332         ZEND_VM_NEXT_OPCODE();
14333 }
14334 
14335 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14336 {
14337         USE_OPLINE
14338         zend_free_op free_op1;
14339 
14340         SAVE_OPLINE();
14341         concat_function(&EX_T(opline->result.var).tmp_var,
14342                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14343                 opline->op2.zv TSRMLS_CC);
14344         zval_ptr_dtor_nogc(&free_op1.var);
14345 
14346         CHECK_EXCEPTION();
14347         ZEND_VM_NEXT_OPCODE();
14348 }
14349 
14350 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14351 {
14352         USE_OPLINE
14353         zend_free_op free_op1;
14354 
14355         SAVE_OPLINE();
14356         is_identical_function(&EX_T(opline->result.var).tmp_var,
14357                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14358                 opline->op2.zv TSRMLS_CC);
14359         zval_ptr_dtor_nogc(&free_op1.var);
14360 
14361         CHECK_EXCEPTION();
14362         ZEND_VM_NEXT_OPCODE();
14363 }
14364 
14365 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14366 {
14367         USE_OPLINE
14368         zend_free_op free_op1;
14369         zval *result = &EX_T(opline->result.var).tmp_var;
14370 
14371         SAVE_OPLINE();
14372         is_identical_function(result,
14373                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14374                 opline->op2.zv TSRMLS_CC);
14375         Z_LVAL_P(result) = !Z_LVAL_P(result);
14376         zval_ptr_dtor_nogc(&free_op1.var);
14377 
14378         CHECK_EXCEPTION();
14379         ZEND_VM_NEXT_OPCODE();
14380 }
14381 
14382 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14383 {
14384         USE_OPLINE
14385         zend_free_op free_op1;
14386         zval *result = &EX_T(opline->result.var).tmp_var;
14387 
14388         SAVE_OPLINE();
14389         ZVAL_BOOL(result, fast_equal_function(result,
14390                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14391                 opline->op2.zv TSRMLS_CC));
14392         zval_ptr_dtor_nogc(&free_op1.var);
14393 
14394         CHECK_EXCEPTION();
14395         ZEND_VM_NEXT_OPCODE();
14396 }
14397 
14398 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14399 {
14400         USE_OPLINE
14401         zend_free_op free_op1;
14402         zval *result = &EX_T(opline->result.var).tmp_var;
14403 
14404         SAVE_OPLINE();
14405         ZVAL_BOOL(result, fast_not_equal_function(result,
14406                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14407                 opline->op2.zv TSRMLS_CC));
14408         zval_ptr_dtor_nogc(&free_op1.var);
14409 
14410         CHECK_EXCEPTION();
14411         ZEND_VM_NEXT_OPCODE();
14412 }
14413 
14414 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14415 {
14416         USE_OPLINE
14417         zend_free_op free_op1;
14418         zval *result = &EX_T(opline->result.var).tmp_var;
14419 
14420         SAVE_OPLINE();
14421         ZVAL_BOOL(result, fast_is_smaller_function(result,
14422                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14423                 opline->op2.zv TSRMLS_CC));
14424         zval_ptr_dtor_nogc(&free_op1.var);
14425 
14426         CHECK_EXCEPTION();
14427         ZEND_VM_NEXT_OPCODE();
14428 }
14429 
14430 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14431 {
14432         USE_OPLINE
14433         zend_free_op free_op1;
14434         zval *result = &EX_T(opline->result.var).tmp_var;
14435 
14436         SAVE_OPLINE();
14437         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
14438                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14439                 opline->op2.zv TSRMLS_CC));
14440         zval_ptr_dtor_nogc(&free_op1.var);
14441 
14442         CHECK_EXCEPTION();
14443         ZEND_VM_NEXT_OPCODE();
14444 }
14445 
14446 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14447 {
14448         USE_OPLINE
14449         zend_free_op free_op1;
14450 
14451         SAVE_OPLINE();
14452         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
14453                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14454                 opline->op2.zv TSRMLS_CC);
14455         zval_ptr_dtor_nogc(&free_op1.var);
14456 
14457         CHECK_EXCEPTION();
14458         ZEND_VM_NEXT_OPCODE();
14459 }
14460 
14461 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14462 {
14463         USE_OPLINE
14464         zend_free_op free_op1;
14465 
14466         SAVE_OPLINE();
14467         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
14468                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14469                 opline->op2.zv TSRMLS_CC);
14470         zval_ptr_dtor_nogc(&free_op1.var);
14471 
14472         CHECK_EXCEPTION();
14473         ZEND_VM_NEXT_OPCODE();
14474 }
14475 
14476 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14477 {
14478         USE_OPLINE
14479         zend_free_op free_op1;
14480 
14481         SAVE_OPLINE();
14482         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
14483                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14484                 opline->op2.zv TSRMLS_CC);
14485         zval_ptr_dtor_nogc(&free_op1.var);
14486 
14487         CHECK_EXCEPTION();
14488         ZEND_VM_NEXT_OPCODE();
14489 }
14490 
14491 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14492 {
14493         USE_OPLINE
14494         zend_free_op free_op1;
14495 
14496         SAVE_OPLINE();
14497         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
14498                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
14499                 opline->op2.zv TSRMLS_CC);
14500         zval_ptr_dtor_nogc(&free_op1.var);
14501 
14502         CHECK_EXCEPTION();
14503         ZEND_VM_NEXT_OPCODE();
14504 }
14505 
14506 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
14507 {
14508         USE_OPLINE
14509         zend_free_op free_op1, free_op_data1;
14510         zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14511         zval *object;
14512         zval *property = opline->op2.zv;
14513         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
14514         int have_get_ptr = 0;
14515 
14516         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
14517                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
14518         }
14519 
14520         make_real_object(object_ptr TSRMLS_CC);
14521         object = *object_ptr;
14522 
14523         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
14524                 zend_error(E_WARNING, "Attempt to assign property of non-object");
14525 
14526                 FREE_OP(free_op_data1);
14527 
14528                 if (RETURN_VALUE_USED(opline)) {
14529                         PZVAL_LOCK(&EG(uninitialized_zval));
14530                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
14531                 }
14532         } else {
14533                 /* here we are sure we are dealing with an object */
14534                 if (0) {
14535                         MAKE_REAL_ZVAL_PTR(property);
14536                 }
14537 
14538                 /* here property is a string */
14539                 if (opline->extended_value == ZEND_ASSIGN_OBJ
14540                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
14541                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14542                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
14543                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
14544 
14545                                 have_get_ptr = 1;
14546                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
14547                                 if (RETURN_VALUE_USED(opline)) {
14548                                         PZVAL_LOCK(*zptr);
14549                                         EX_T(opline->result.var).var.ptr = *zptr;
14550                                 }
14551                         }
14552                 }
14553 
14554                 if (!have_get_ptr) {
14555                         zval *z = NULL;
14556 
14557                         Z_ADDREF_P(object);
14558                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
14559                                 if (Z_OBJ_HT_P(object)->read_property) {
14560                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14561                                 }
14562                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
14563                                 if (Z_OBJ_HT_P(object)->read_dimension) {
14564                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
14565                                 }
14566                         }
14567                         if (z) {
14568                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
14569                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
14570 
14571                                         if (Z_REFCOUNT_P(z) == 0) {
14572                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
14573                                                 zval_dtor(z);
14574                                                 FREE_ZVAL(z);
14575                                         }
14576                                         z = value;
14577                                 }
14578                                 Z_ADDREF_P(z);
14579                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
14580                                 binary_op(z, z, value TSRMLS_CC);
14581                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
14582                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14583                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
14584                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
14585                                 }
14586                                 if (RETURN_VALUE_USED(opline)) {
14587                                         PZVAL_LOCK(z);
14588                                         EX_T(opline->result.var).var.ptr = z;
14589                                 }
14590                                 zval_ptr_dtor(&z);
14591                         } else {
14592                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
14593                                 if (RETURN_VALUE_USED(opline)) {
14594                                         PZVAL_LOCK(&EG(uninitialized_zval));
14595                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
14596                                 }
14597                         }
14598                         zval_ptr_dtor(&object);
14599                 }
14600 
14601                 if (0) {
14602                         zval_ptr_dtor(&property);
14603                 } else {
14604 
14605                 }
14606                 FREE_OP(free_op_data1);
14607         }
14608 
14609         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14610         /* assign_obj has two opcodes! */
14611         CHECK_EXCEPTION();
14612         ZEND_VM_INC_OPCODE();
14613         ZEND_VM_NEXT_OPCODE();
14614 }
14615 
14616 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
14617 {
14618         USE_OPLINE
14619         zend_free_op free_op1, free_op_data2, free_op_data1;
14620         zval **var_ptr;
14621         zval *value;
14622 
14623         SAVE_OPLINE();
14624         switch (opline->extended_value) {
14625                 case ZEND_ASSIGN_OBJ:
14626                         return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14627                         break;
14628                 case ZEND_ASSIGN_DIM: {
14629                                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14630 
14631                                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
14632                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
14633                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
14634                                         if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
14635                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
14636                                         }
14637                                         return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14638                                 } else {
14639                                         zval *dim = opline->op2.zv;
14640 
14641                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
14642                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
14643                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
14644                                 }
14645                         }
14646                         break;
14647                 default:
14648                         value = opline->op2.zv;
14649                         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14650                         /* do nothing */
14651                         break;
14652         }
14653 
14654         if (UNEXPECTED(var_ptr == NULL)) {
14655                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
14656         }
14657 
14658         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
14659                 if (RETURN_VALUE_USED(opline)) {
14660                         PZVAL_LOCK(&EG(uninitialized_zval));
14661                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
14662                 }
14663 
14664                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14665                 CHECK_EXCEPTION();
14666                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
14667                         ZEND_VM_INC_OPCODE();
14668                 }
14669                 ZEND_VM_NEXT_OPCODE();
14670         }
14671 
14672         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
14673 
14674         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
14675            && Z_OBJ_HANDLER_PP(var_ptr, get)
14676            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
14677                 /* proxy object */
14678                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
14679                 Z_ADDREF_P(objval);
14680                 binary_op(objval, objval, value TSRMLS_CC);
14681                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
14682                 zval_ptr_dtor(&objval);
14683         } else {
14684                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
14685         }
14686 
14687         if (RETURN_VALUE_USED(opline)) {
14688                 PZVAL_LOCK(*var_ptr);
14689                 EX_T(opline->result.var).var.ptr = *var_ptr;
14690         }
14691 
14692         if (opline->extended_value == ZEND_ASSIGN_DIM) {
14693                 FREE_OP(free_op_data1);
14694                 FREE_OP_VAR_PTR(free_op_data2);
14695                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14696                 CHECK_EXCEPTION();
14697                 ZEND_VM_INC_OPCODE();
14698         } else {
14699                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14700                 CHECK_EXCEPTION();
14701         }
14702         ZEND_VM_NEXT_OPCODE();
14703 }
14704 
14705 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14706 {
14707         return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14708 }
14709 
14710 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14711 {
14712         return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14713 }
14714 
14715 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14716 {
14717         return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14718 }
14719 
14720 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14721 {
14722         return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14723 }
14724 
14725 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14726 {
14727         return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14728 }
14729 
14730 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14731 {
14732         return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14733 }
14734 
14735 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14736 {
14737         return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14738 }
14739 
14740 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14741 {
14742         return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14743 }
14744 
14745 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14746 {
14747         return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14748 }
14749 
14750 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14751 {
14752         return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14753 }
14754 
14755 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14756 {
14757         return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14758 }
14759 
14760 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
14761 {
14762         USE_OPLINE
14763         zend_free_op free_op1;
14764         zval **object_ptr;
14765         zval *object;
14766         zval *property;
14767         zval **retval;
14768         int have_get_ptr = 0;
14769 
14770         SAVE_OPLINE();
14771         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14772         property = opline->op2.zv;
14773         retval = &EX_T(opline->result.var).var.ptr;
14774 
14775         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
14776                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
14777         }
14778 
14779         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
14780         object = *object_ptr;
14781 
14782         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
14783                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
14784 
14785                 if (RETURN_VALUE_USED(opline)) {
14786                         PZVAL_LOCK(&EG(uninitialized_zval));
14787                         *retval = &EG(uninitialized_zval);
14788                 }
14789                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14790                 CHECK_EXCEPTION();
14791                 ZEND_VM_NEXT_OPCODE();
14792         }
14793 
14794         /* here we are sure we are dealing with an object */
14795 
14796         if (0) {
14797                 MAKE_REAL_ZVAL_PTR(property);
14798         }
14799 
14800         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
14801                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14802                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
14803                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
14804 
14805                         have_get_ptr = 1;
14806                         incdec_op(*zptr);
14807                         if (RETURN_VALUE_USED(opline)) {
14808                                 *retval = *zptr;
14809                                 PZVAL_LOCK(*retval);
14810                         }
14811                 }
14812         }
14813 
14814         if (!have_get_ptr) {
14815                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
14816                         zval *z;
14817 
14818                         Z_ADDREF_P(object);
14819                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14820 
14821                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
14822                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
14823 
14824                                 if (Z_REFCOUNT_P(z) == 0) {
14825                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
14826                                         zval_dtor(z);
14827                                         FREE_ZVAL(z);
14828                                 }
14829                                 z = value;
14830                         }
14831                         Z_ADDREF_P(z);
14832                         SEPARATE_ZVAL_IF_NOT_REF(&z);
14833                         incdec_op(z);
14834                         *retval = z;
14835                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14836                         zval_ptr_dtor(&object);
14837                         SELECTIVE_PZVAL_LOCK(*retval, opline);
14838                         zval_ptr_dtor(&z);
14839                 } else {
14840                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
14841                         if (RETURN_VALUE_USED(opline)) {
14842                                 PZVAL_LOCK(&EG(uninitialized_zval));
14843                                 *retval = &EG(uninitialized_zval);
14844                         }
14845                 }
14846         }
14847 
14848         if (0) {
14849                 zval_ptr_dtor(&property);
14850         } else {
14851 
14852         }
14853         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14854         CHECK_EXCEPTION();
14855         ZEND_VM_NEXT_OPCODE();
14856 }
14857 
14858 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14859 {
14860         return zend_pre_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14861 }
14862 
14863 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14864 {
14865         return zend_pre_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14866 }
14867 
14868 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
14869 {
14870         USE_OPLINE
14871         zend_free_op free_op1;
14872         zval **object_ptr;
14873         zval *object;
14874         zval *property;
14875         zval *retval;
14876         int have_get_ptr = 0;
14877 
14878         SAVE_OPLINE();
14879         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14880         property = opline->op2.zv;
14881         retval = &EX_T(opline->result.var).tmp_var;
14882 
14883         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
14884                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
14885         }
14886 
14887         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
14888         object = *object_ptr;
14889 
14890         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
14891                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
14892 
14893                 ZVAL_NULL(retval);
14894                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14895                 CHECK_EXCEPTION();
14896                 ZEND_VM_NEXT_OPCODE();
14897         }
14898 
14899         /* here we are sure we are dealing with an object */
14900 
14901         if (0) {
14902                 MAKE_REAL_ZVAL_PTR(property);
14903         }
14904 
14905         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
14906                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14907                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
14908                         have_get_ptr = 1;
14909                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
14910 
14911                         ZVAL_COPY_VALUE(retval, *zptr);
14912                         zendi_zval_copy_ctor(*retval);
14913 
14914                         incdec_op(*zptr);
14915 
14916                 }
14917         }
14918 
14919         if (!have_get_ptr) {
14920                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
14921                         zval *z, *z_copy;
14922 
14923                         Z_ADDREF_P(object);
14924                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14925                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
14926                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
14927 
14928                                 if (Z_REFCOUNT_P(z) == 0) {
14929                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
14930                                         zval_dtor(z);
14931                                         FREE_ZVAL(z);
14932                                 }
14933                                 z = value;
14934                         }
14935                         ZVAL_COPY_VALUE(retval, z);
14936                         zendi_zval_copy_ctor(*retval);
14937                         ALLOC_ZVAL(z_copy);
14938                         INIT_PZVAL_COPY(z_copy, z);
14939                         zendi_zval_copy_ctor(*z_copy);
14940                         incdec_op(z_copy);
14941                         Z_ADDREF_P(z);
14942                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
14943                         zval_ptr_dtor(&object);
14944                         zval_ptr_dtor(&z_copy);
14945                         zval_ptr_dtor(&z);
14946                 } else {
14947                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
14948                         ZVAL_NULL(retval);
14949                 }
14950         }
14951 
14952         if (0) {
14953                 zval_ptr_dtor(&property);
14954         } else {
14955 
14956         }
14957         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
14958         CHECK_EXCEPTION();
14959         ZEND_VM_NEXT_OPCODE();
14960 }
14961 
14962 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14963 {
14964         return zend_post_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14965 }
14966 
14967 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14968 {
14969         return zend_post_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
14970 }
14971 
14972 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
14973 {
14974         USE_OPLINE
14975         zend_free_op free_op1;
14976         zval *varname;
14977         zval **retval;
14978         zval tmp_varname;
14979         HashTable *target_symbol_table;
14980         ulong hash_value;
14981 
14982         SAVE_OPLINE();
14983         varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
14984 
14985         if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
14986                 ZVAL_COPY_VALUE(&tmp_varname, varname);
14987                 zval_copy_ctor(&tmp_varname);
14988                 Z_SET_REFCOUNT(tmp_varname, 1);
14989                 Z_UNSET_ISREF(tmp_varname);
14990                 convert_to_string(&tmp_varname);
14991                 varname = &tmp_varname;
14992         }
14993 
14994         if (IS_CONST != IS_UNUSED) {
14995                 zend_class_entry *ce;
14996 
14997                 if (IS_CONST == IS_CONST) {
14998                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
14999                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
15000                         } else {
15001                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
15002                                 if (UNEXPECTED(ce == NULL)) {
15003                                         if (IS_VAR != IS_CONST && varname == &tmp_varname) {
15004                                                 zval_dtor(&tmp_varname);
15005                                         }
15006                                         zval_ptr_dtor_nogc(&free_op1.var);
15007                                         CHECK_EXCEPTION();
15008                                         ZEND_VM_NEXT_OPCODE();
15009                                 }
15010                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
15011                         }
15012                 } else {
15013                         ce = EX_T(opline->op2.var).class_entry;
15014                 }
15015                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
15016                 zval_ptr_dtor_nogc(&free_op1.var);
15017         } else {
15018                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
15019 /*
15020                 if (!target_symbol_table) {
15021                         CHECK_EXCEPTION();
15022                         ZEND_VM_NEXT_OPCODE();
15023                 }
15024 */
15025                 if (IS_VAR == IS_CONST) {
15026                         hash_value = Z_HASH_P(varname);
15027                 } else {
15028                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
15029                 }
15030 
15031                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
15032                         switch (type) {
15033                                 case BP_VAR_R:
15034                                 case BP_VAR_UNSET:
15035                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
15036                                         /* break missing intentionally */
15037                                 case BP_VAR_IS:
15038                                         retval = &EG(uninitialized_zval_ptr);
15039                                         break;
15040                                 case BP_VAR_RW:
15041                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
15042                                         /* break missing intentionally */
15043                                 case BP_VAR_W:
15044                                         Z_ADDREF_P(&EG(uninitialized_zval));
15045                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
15046                                         break;
15047                                 EMPTY_SWITCH_DEFAULT_CASE()
15048                         }
15049                 }
15050                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
15051                         case ZEND_FETCH_GLOBAL:
15052                                 if (IS_VAR != IS_TMP_VAR) {
15053                                         zval_ptr_dtor_nogc(&free_op1.var);
15054                                 }
15055                                 break;
15056                         case ZEND_FETCH_LOCAL:
15057                                 zval_ptr_dtor_nogc(&free_op1.var);
15058                                 break;
15059                         case ZEND_FETCH_STATIC:
15060                                 zval_update_constant(retval, 1 TSRMLS_CC);
15061                                 break;
15062                         case ZEND_FETCH_GLOBAL_LOCK:
15063                                 if (IS_VAR == IS_VAR && !free_op1.var) {
15064                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
15065                                 }
15066                                 break;
15067                 }
15068         }
15069 
15070 
15071         if (IS_VAR != IS_CONST && varname == &tmp_varname) {
15072                 zval_dtor(&tmp_varname);
15073         }
15074         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
15075                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
15076         }
15077         PZVAL_LOCK(*retval);
15078         switch (type) {
15079                 case BP_VAR_R:
15080                 case BP_VAR_IS:
15081                         EX_T(opline->result.var).var.ptr = *retval;
15082                         break;
15083                 case BP_VAR_UNSET: {
15084                         zend_free_op free_res;
15085 
15086                         PZVAL_UNLOCK(*retval, &free_res);
15087                         if (retval != &EG(uninitialized_zval_ptr)) {
15088                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
15089                         }
15090                         PZVAL_LOCK(*retval);
15091                         FREE_OP_VAR_PTR(free_res);
15092                 }
15093                 /* break missing intentionally */
15094                 default:
15095                         EX_T(opline->result.var).var.ptr_ptr = retval;
15096                         break;
15097         }
15098         CHECK_EXCEPTION();
15099         ZEND_VM_NEXT_OPCODE();
15100 }
15101 
15102 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15103 {
15104         return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15105 }
15106 
15107 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15108 {
15109         return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15110 }
15111 
15112 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15113 {
15114         return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15115 }
15116 
15117 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15118 {
15119         USE_OPLINE
15120 
15121         return zend_fetch_var_address_helper_SPEC_VAR_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15122 }
15123 
15124 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15125 {
15126         return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15127 }
15128 
15129 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15130 {
15131         return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15132 }
15133 
15134 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15135 {
15136         USE_OPLINE
15137         zend_free_op free_op1;
15138         zval *container;
15139 
15140         SAVE_OPLINE();
15141         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15142         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
15143 
15144         if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
15145                 zval_ptr_dtor_nogc(&free_op1.var);
15146         }
15147         CHECK_EXCEPTION();
15148         ZEND_VM_NEXT_OPCODE();
15149 }
15150 
15151 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15152 {
15153         USE_OPLINE
15154         zend_free_op free_op1;
15155         zval **container;
15156 
15157         SAVE_OPLINE();
15158         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15159 
15160         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15161                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15162         }
15163         zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
15164 
15165         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15166                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15167         }
15168         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15169 
15170         /* We are going to assign the result by reference */
15171         if (UNEXPECTED(opline->extended_value != 0)) {
15172                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
15173 
15174                 if (retval_ptr) {
15175                         Z_DELREF_PP(retval_ptr);
15176                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
15177                         Z_ADDREF_PP(retval_ptr);
15178                 }
15179         }
15180 
15181         CHECK_EXCEPTION();
15182         ZEND_VM_NEXT_OPCODE();
15183 }
15184 
15185 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15186 {
15187         USE_OPLINE
15188         zend_free_op free_op1;
15189         zval **container;
15190 
15191         SAVE_OPLINE();
15192         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15193 
15194         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15195                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15196         }
15197         zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC);
15198 
15199         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15200                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15201         }
15202         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15203         CHECK_EXCEPTION();
15204         ZEND_VM_NEXT_OPCODE();
15205 }
15206 
15207 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15208 {
15209         USE_OPLINE
15210         zend_free_op free_op1;
15211         zval *container;
15212 
15213         SAVE_OPLINE();
15214         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15215         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC);
15216 
15217         zval_ptr_dtor_nogc(&free_op1.var);
15218         CHECK_EXCEPTION();
15219         ZEND_VM_NEXT_OPCODE();
15220 }
15221 
15222 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15223 {
15224         USE_OPLINE
15225         zend_free_op free_op1;
15226 
15227         SAVE_OPLINE();
15228 
15229         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
15230                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15231                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15232                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15233                 }
15234                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
15235                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15236                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15237                 }
15238 
15239                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15240         } else {
15241                 zval *container;
15242 
15243                 if (IS_CONST == IS_UNUSED) {
15244                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
15245                 }
15246                 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15247                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
15248 
15249                 zval_ptr_dtor_nogc(&free_op1.var);
15250         }
15251         CHECK_EXCEPTION();
15252         ZEND_VM_NEXT_OPCODE();
15253 }
15254 
15255 static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15256 {
15257         USE_OPLINE
15258         zend_free_op free_op1;
15259         zval **container;
15260 
15261         SAVE_OPLINE();
15262         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15263 
15264         if (IS_VAR == IS_CV) {
15265                 if (container != &EG(uninitialized_zval_ptr)) {
15266                         SEPARATE_ZVAL_IF_NOT_REF(container);
15267                 }
15268         }
15269         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15270                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15271         }
15272         zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC);
15273 
15274         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15275                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15276         }
15277         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15278         if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
15279                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
15280                 ZEND_VM_NEXT_OPCODE();
15281         } else {
15282                 zend_free_op free_res;
15283                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
15284 
15285                 PZVAL_UNLOCK(*retval_ptr, &free_res);
15286                 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
15287                         SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
15288                 }
15289                 PZVAL_LOCK(*retval_ptr);
15290                 FREE_OP_VAR_PTR(free_res);
15291                 CHECK_EXCEPTION();
15292                 ZEND_VM_NEXT_OPCODE();
15293         }
15294 }
15295 
15296 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS)
15297 {
15298         USE_OPLINE
15299         zend_free_op free_op1;
15300         zval *container;
15301 
15302         zval *offset;
15303 
15304         SAVE_OPLINE();
15305         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15306         offset  = opline->op2.zv;
15307 
15308         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
15309             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
15310                 zend_error(E_NOTICE, "Trying to get property of non-object");
15311                 PZVAL_LOCK(&EG(uninitialized_zval));
15312                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15313 
15314         } else {
15315                 zval *retval;
15316 
15317                 if (0) {
15318                         MAKE_REAL_ZVAL_PTR(offset);
15319                 }
15320 
15321                 /* here we are sure we are dealing with an object */
15322                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
15323 
15324                 PZVAL_LOCK(retval);
15325                 EX_T(opline->result.var).var.ptr = retval;
15326 
15327                 if (0) {
15328                         zval_ptr_dtor(&offset);
15329                 } else {
15330 
15331                 }
15332         }
15333 
15334         zval_ptr_dtor_nogc(&free_op1.var);
15335         CHECK_EXCEPTION();
15336         ZEND_VM_NEXT_OPCODE();
15337 }
15338 
15339 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15340 {
15341         return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15342 }
15343 
15344 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15345 {
15346         USE_OPLINE
15347         zend_free_op free_op1;
15348         zval *property;
15349         zval **container;
15350 
15351         SAVE_OPLINE();
15352         property = opline->op2.zv;
15353 
15354         if (0) {
15355                 MAKE_REAL_ZVAL_PTR(property);
15356         }
15357         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15358         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15359                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15360         }
15361 
15362         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
15363         if (0) {
15364                 zval_ptr_dtor(&property);
15365         } else {
15366 
15367         }
15368         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15369                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15370         }
15371         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15372 
15373         /* We are going to assign the result by reference */
15374         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
15375                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
15376 
15377                 Z_DELREF_PP(retval_ptr);
15378                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
15379                 Z_ADDREF_PP(retval_ptr);
15380                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
15381                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
15382         }
15383 
15384         CHECK_EXCEPTION();
15385         ZEND_VM_NEXT_OPCODE();
15386 }
15387 
15388 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15389 {
15390         USE_OPLINE
15391         zend_free_op free_op1;
15392         zval *property;
15393         zval **container;
15394 
15395         SAVE_OPLINE();
15396         property = opline->op2.zv;
15397         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15398 
15399         if (0) {
15400                 MAKE_REAL_ZVAL_PTR(property);
15401         }
15402         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15403                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15404         }
15405         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
15406         if (0) {
15407                 zval_ptr_dtor(&property);
15408         } else {
15409 
15410         }
15411         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15412                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15413         }
15414         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15415         CHECK_EXCEPTION();
15416         ZEND_VM_NEXT_OPCODE();
15417 }
15418 
15419 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15420 {
15421         USE_OPLINE
15422         zend_free_op free_op1;
15423         zval *container;
15424 
15425         zval *offset;
15426 
15427         SAVE_OPLINE();
15428         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15429         offset  = opline->op2.zv;
15430 
15431         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
15432             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
15433                 PZVAL_LOCK(&EG(uninitialized_zval));
15434                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15435 
15436         } else {
15437                 zval *retval;
15438 
15439                 if (0) {
15440                         MAKE_REAL_ZVAL_PTR(offset);
15441                 }
15442 
15443                 /* here we are sure we are dealing with an object */
15444                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
15445 
15446                 PZVAL_LOCK(retval);
15447                 EX_T(opline->result.var).var.ptr = retval;
15448 
15449                 if (0) {
15450                         zval_ptr_dtor(&offset);
15451                 } else {
15452 
15453                 }
15454         }
15455 
15456         zval_ptr_dtor_nogc(&free_op1.var);
15457         CHECK_EXCEPTION();
15458         ZEND_VM_NEXT_OPCODE();
15459 }
15460 
15461 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15462 {
15463         USE_OPLINE
15464 
15465         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
15466                 /* Behave like FETCH_OBJ_W */
15467                 zend_free_op free_op1;
15468                 zval *property;
15469                 zval **container;
15470 
15471                 SAVE_OPLINE();
15472                 property = opline->op2.zv;
15473                 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15474 
15475                 if (0) {
15476                         MAKE_REAL_ZVAL_PTR(property);
15477                 }
15478                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15479                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15480                 }
15481                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
15482                 if (0) {
15483                         zval_ptr_dtor(&property);
15484                 } else {
15485 
15486                 }
15487                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15488                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15489                 }
15490                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15491                 CHECK_EXCEPTION();
15492                 ZEND_VM_NEXT_OPCODE();
15493         } else {
15494                 return zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
15495         }
15496 }
15497 
15498 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15499 {
15500         USE_OPLINE
15501         zend_free_op free_op1, free_res;
15502         zval **container;
15503         zval *property;
15504 
15505         SAVE_OPLINE();
15506         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15507         property = opline->op2.zv;
15508 
15509         if (IS_VAR == IS_CV) {
15510                 if (container != &EG(uninitialized_zval_ptr)) {
15511                         SEPARATE_ZVAL_IF_NOT_REF(container);
15512                 }
15513         }
15514         if (0) {
15515                 MAKE_REAL_ZVAL_PTR(property);
15516         }
15517         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
15518                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
15519         }
15520         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
15521         if (0) {
15522                 zval_ptr_dtor(&property);
15523         } else {
15524 
15525         }
15526         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
15527                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
15528         }
15529         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15530 
15531         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
15532         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
15533                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
15534         }
15535         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
15536         FREE_OP_VAR_PTR(free_res);
15537         CHECK_EXCEPTION();
15538         ZEND_VM_NEXT_OPCODE();
15539 }
15540 
15541 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15542 {
15543         USE_OPLINE
15544         zend_free_op free_op1;
15545         zval **object_ptr;
15546         zval *property_name;
15547 
15548         SAVE_OPLINE();
15549         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15550         property_name = opline->op2.zv;
15551 
15552         if (0) {
15553                 MAKE_REAL_ZVAL_PTR(property_name);
15554         }
15555         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
15556                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15557         }
15558         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
15559         if (0) {
15560                 zval_ptr_dtor(&property_name);
15561         } else {
15562 
15563         }
15564         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15565         /* assign_obj has two opcodes! */
15566         CHECK_EXCEPTION();
15567         ZEND_VM_INC_OPCODE();
15568         ZEND_VM_NEXT_OPCODE();
15569 }
15570 
15571 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15572 {
15573         USE_OPLINE
15574         zend_free_op free_op1;
15575         zval **object_ptr;
15576 
15577         SAVE_OPLINE();
15578         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15579 
15580         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
15581                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
15582         }
15583         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
15584 
15585                 zval *property_name = opline->op2.zv;
15586 
15587                 if (0) {
15588                         MAKE_REAL_ZVAL_PTR(property_name);
15589                 }
15590                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
15591                 if (0) {
15592                         zval_ptr_dtor(&property_name);
15593                 } else {
15594 
15595                 }
15596         } else {
15597                 zend_free_op free_op_data1, free_op_data2;
15598                 zval *value;
15599                 zval *dim = opline->op2.zv;
15600                 zval **variable_ptr_ptr;
15601 
15602                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC);
15603 
15604                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
15605                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
15606                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
15607                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
15608                                 if (RETURN_VALUE_USED(opline)) {
15609                                         zval *retval;
15610 
15611                                         ALLOC_ZVAL(retval);
15612                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
15613                                         INIT_PZVAL(retval);
15614                                         EX_T(opline->result.var).var.ptr = retval;
15615                                 }
15616                         } else if (RETURN_VALUE_USED(opline)) {
15617                                 PZVAL_LOCK(&EG(uninitialized_zval));
15618                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15619                         }
15620                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
15621                         if (IS_TMP_FREE(free_op_data1)) {
15622                                 zval_dtor(value);
15623                         }
15624                         if (RETURN_VALUE_USED(opline)) {
15625                                 PZVAL_LOCK(&EG(uninitialized_zval));
15626                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15627                         }
15628                 } else {
15629                         if ((opline+1)->op1_type == IS_TMP_VAR) {
15630                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15631                         } else if ((opline+1)->op1_type == IS_CONST) {
15632                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15633                         } else {
15634                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15635                         }
15636                         if (RETURN_VALUE_USED(opline)) {
15637                                 PZVAL_LOCK(value);
15638                                 EX_T(opline->result.var).var.ptr = value;
15639                         }
15640                 }
15641                 FREE_OP_VAR_PTR(free_op_data2);
15642                 FREE_OP_IF_VAR(free_op_data1);
15643         }
15644         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
15645         /* assign_dim has two opcodes! */
15646         CHECK_EXCEPTION();
15647         ZEND_VM_INC_OPCODE();
15648         ZEND_VM_NEXT_OPCODE();
15649 }
15650 
15651 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15652 {
15653         USE_OPLINE
15654         zend_free_op free_op1;
15655         zval *value;
15656         zval **variable_ptr_ptr;
15657 
15658         SAVE_OPLINE();
15659         value = opline->op2.zv;
15660         variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15661 
15662         if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
15663                 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
15664                         if (RETURN_VALUE_USED(opline)) {
15665                                 zval *retval;
15666 
15667                                 ALLOC_ZVAL(retval);
15668                                 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
15669                                 INIT_PZVAL(retval);
15670                                 EX_T(opline->result.var).var.ptr = retval;
15671                         }
15672                 } else if (RETURN_VALUE_USED(opline)) {
15673                         PZVAL_LOCK(&EG(uninitialized_zval));
15674                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15675                 }
15676         } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
15677                 if (0) {
15678                         zval_dtor(value);
15679                 }
15680                 if (RETURN_VALUE_USED(opline)) {
15681                         PZVAL_LOCK(&EG(uninitialized_zval));
15682                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
15683                 }
15684         } else {
15685                 if (IS_CONST == IS_TMP_VAR) {
15686                         value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15687                 } else if (IS_CONST == IS_CONST) {
15688                         value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15689                 } else {
15690                         value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
15691                 }
15692                 if (RETURN_VALUE_USED(opline)) {
15693                         PZVAL_LOCK(value);
15694                         EX_T(opline->result.var).var.ptr = value;
15695                 }
15696         }
15697 
15698         if (IS_VAR == IS_VAR && (free_op1.var != NULL)) {
15699                 zval_ptr_dtor_nogc(&value);
15700         }
15701 
15702         /* zend_assign_to_variable() always takes care of op2, never free it! */
15703 
15704         CHECK_EXCEPTION();
15705         ZEND_VM_NEXT_OPCODE();
15706 }
15707 
15708 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15709 {
15710         USE_OPLINE
15711         zval *function_name;
15712         char *function_name_strval;
15713         int function_name_strlen;
15714         zend_free_op free_op1;
15715         call_slot *call = EX(call_slots) + opline->result.num;
15716 
15717         SAVE_OPLINE();
15718 
15719         function_name = opline->op2.zv;
15720 
15721         if (IS_CONST != IS_CONST &&
15722             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
15723                 if (UNEXPECTED(EG(exception) != NULL)) {
15724                         HANDLE_EXCEPTION();
15725                 }
15726                 zend_error_noreturn(E_ERROR, "Method name must be a string");
15727         }
15728 
15729         function_name_strval = Z_STRVAL_P(function_name);
15730         function_name_strlen = Z_STRLEN_P(function_name);
15731 
15732         call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
15733 
15734         if (EXPECTED(call->object != NULL) &&
15735             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
15736                 call->called_scope = Z_OBJCE_P(call->object);
15737 
15738                 if (IS_CONST != IS_CONST ||
15739                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
15740                     zval *object = call->object;
15741 
15742                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
15743                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
15744                         }
15745 
15746                         /* First, locate the function. */
15747                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
15748                         if (UNEXPECTED(call->fbc == NULL)) {
15749                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
15750                         }
15751                         if (IS_CONST == IS_CONST &&
15752                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
15753                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
15754                             EXPECTED(call->object == object)) {
15755                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
15756                         }
15757                 }
15758         } else {
15759                 if (UNEXPECTED(EG(exception) != NULL)) {
15760 
15761                         HANDLE_EXCEPTION();
15762                 }
15763                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
15764         }
15765 
15766         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
15767                 call->object = NULL;
15768         } else {
15769                 if (!PZVAL_IS_REF(call->object)) {
15770                         Z_ADDREF_P(call->object); /* For $this pointer */
15771                 } else {
15772                         zval *this_ptr;
15773                         ALLOC_ZVAL(this_ptr);
15774                         INIT_PZVAL_COPY(this_ptr, call->object);
15775                         zval_copy_ctor(this_ptr);
15776                         call->object = this_ptr;
15777                 }
15778         }
15779 
15780         call->num_additional_args = 0;
15781         call->is_ctor_call = 0;
15782         EX(call) = call;
15783 
15784         zval_ptr_dtor_nogc(&free_op1.var);
15785 
15786         CHECK_EXCEPTION();
15787         ZEND_VM_NEXT_OPCODE();
15788 }
15789 
15790 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15791 {
15792         USE_OPLINE
15793         zval *function_name;
15794         zend_class_entry *ce;
15795         call_slot *call = EX(call_slots) + opline->result.num;
15796 
15797         SAVE_OPLINE();
15798 
15799         if (IS_VAR == IS_CONST) {
15800                 /* no function found. try a static method in class */
15801                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
15802                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
15803                 } else {
15804                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
15805                         if (UNEXPECTED(EG(exception) != NULL)) {
15806                                 HANDLE_EXCEPTION();
15807                         }
15808                         if (UNEXPECTED(ce == NULL)) {
15809                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
15810                         }
15811                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
15812                 }
15813                 call->called_scope = ce;
15814         } else {
15815                 ce = EX_T(opline->op1.var).class_entry;
15816 
15817                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
15818                         call->called_scope = EG(called_scope);
15819                 } else {
15820                         call->called_scope = ce;
15821                 }
15822         }
15823 
15824         if (IS_VAR == IS_CONST &&
15825             IS_CONST == IS_CONST &&
15826             CACHED_PTR(opline->op2.literal->cache_slot)) {
15827                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
15828         } else if (IS_VAR != IS_CONST &&
15829                    IS_CONST == IS_CONST &&
15830                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
15831                 /* do nothing */
15832         } else if (IS_CONST != IS_UNUSED) {
15833                 char *function_name_strval = NULL;
15834                 int function_name_strlen = 0;
15835 
15836 
15837                 if (IS_CONST == IS_CONST) {
15838                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
15839                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
15840                 } else {
15841                         function_name = opline->op2.zv;
15842 
15843                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
15844                                 if (UNEXPECTED(EG(exception) != NULL)) {
15845                                         HANDLE_EXCEPTION();
15846                                 }
15847                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
15848                         } else {
15849                                 function_name_strval = Z_STRVAL_P(function_name);
15850                                 function_name_strlen = Z_STRLEN_P(function_name);
15851                         }
15852                 }
15853 
15854                 if (function_name_strval) {
15855                         if (ce->get_static_method) {
15856                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
15857                         } else {
15858                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
15859                         }
15860                         if (UNEXPECTED(call->fbc == NULL)) {
15861                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
15862                         }
15863                         if (IS_CONST == IS_CONST &&
15864                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
15865                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
15866                                 if (IS_VAR == IS_CONST) {
15867                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
15868                                 } else {
15869                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
15870                                 }
15871                         }
15872                 }
15873                 if (IS_CONST != IS_CONST) {
15874 
15875                 }
15876         } else {
15877                 if (UNEXPECTED(ce->constructor == NULL)) {
15878                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
15879                 }
15880                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
15881                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
15882                 }
15883                 call->fbc = ce->constructor;
15884         }
15885 
15886         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
15887                 call->object = NULL;
15888         } else {
15889                 if (EG(This) &&
15890                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
15891                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
15892                     /* We are calling method of the other (incompatible) class,
15893                        but passing $this. This is done for compatibility with php-4. */
15894                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
15895                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
15896                         } else {
15897                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
15898                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
15899                         }
15900                 }
15901                 if ((call->object = EG(This))) {
15902                         Z_ADDREF_P(call->object);
15903                         call->called_scope = Z_OBJCE_P(call->object);
15904                 }
15905         }
15906 
15907         call->num_additional_args = 0;
15908         call->is_ctor_call = 0;
15909         EX(call) = call;
15910 
15911         CHECK_EXCEPTION();
15912         ZEND_VM_NEXT_OPCODE();
15913 }
15914 
15915 static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15916 {
15917         USE_OPLINE
15918         zend_free_op free_op1;
15919 
15920         SAVE_OPLINE();
15921         is_equal_function(&EX_T(opline->result.var).tmp_var,
15922                                  _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
15923                                  opline->op2.zv TSRMLS_CC);
15924 
15925         CHECK_EXCEPTION();
15926         ZEND_VM_NEXT_OPCODE();
15927 }
15928 
15929 static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15930 {
15931         USE_OPLINE
15932 
15933         SAVE_OPLINE();
15934         if (IS_VAR == IS_UNUSED) {
15935                 zend_constant *c;
15936                 zval *retval;
15937 
15938                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
15939                         c = CACHED_PTR(opline->op2.literal->cache_slot);
15940                 } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
15941                         if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
15942                                 char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
15943                                 if(!actual) {
15944                                         actual = Z_STRVAL_P(opline->op2.zv);
15945                                 } else {
15946                                         actual++;
15947                                 }
15948                                 /* non-qualified constant - allow text substitution */
15949                                 zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
15950                                 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
15951                                 CHECK_EXCEPTION();
15952                                 ZEND_VM_NEXT_OPCODE();
15953                         } else {
15954                                 zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
15955                         }
15956                 } else {
15957                         CACHE_PTR(opline->op2.literal->cache_slot, c);
15958                 }
15959                 retval = &EX_T(opline->result.var).tmp_var;
15960                 ZVAL_COPY_VALUE(retval, &c->value);
15961                 zval_copy_ctor(retval);
15962         } else {
15963                 /* class constant */
15964                 zend_class_entry *ce;
15965                 zval **value;
15966 
15967                 if (IS_VAR == IS_CONST) {
15968                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
15969                                 value = CACHED_PTR(opline->op2.literal->cache_slot);
15970                                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
15971                                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
15972                                 goto constant_fetch_end;
15973                         } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
15974                                 ce = CACHED_PTR(opline->op1.literal->cache_slot);
15975                         } else {
15976                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
15977                                 if (UNEXPECTED(EG(exception) != NULL)) {
15978                                         HANDLE_EXCEPTION();
15979                                 }
15980                                 if (UNEXPECTED(ce == NULL)) {
15981                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
15982                                 }
15983                                 CACHE_PTR(opline->op1.literal->cache_slot, ce);
15984                         }
15985                 } else {
15986                         ce = EX_T(opline->op1.var).class_entry;
15987                         if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
15988                                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
15989                                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
15990                                 goto constant_fetch_end;
15991                         }
15992                 }
15993 
15994                 if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
15995                         if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
15996                                 zend_class_entry *old_scope = EG(scope);
15997 
15998                                 EG(scope) = ce;
15999                                 zval_update_constant(value, 1 TSRMLS_CC);
16000                                 EG(scope) = old_scope;
16001                         }
16002                         if (IS_VAR == IS_CONST) {
16003                                 CACHE_PTR(opline->op2.literal->cache_slot, value);
16004                         } else {
16005                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
16006                         }
16007                         ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
16008                         zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
16009                 } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
16010                         /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
16011                         ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
16012                 } else {
16013                         zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
16014                 }
16015         }
16016 constant_fetch_end:
16017         CHECK_EXCEPTION();
16018         ZEND_VM_NEXT_OPCODE();
16019 }
16020 
16021 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16022 {
16023         USE_OPLINE
16024         zend_free_op free_op1;
16025         zval *expr_ptr;
16026 
16027         SAVE_OPLINE();
16028         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
16029                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16030 
16031                 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
16032                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
16033                 }
16034                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
16035                 expr_ptr = *expr_ptr_ptr;
16036                 Z_ADDREF_P(expr_ptr);
16037         } else {
16038                 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16039                 if (0) { /* temporary variable */
16040                         zval *new_expr;
16041 
16042                         ALLOC_ZVAL(new_expr);
16043                         INIT_PZVAL_COPY(new_expr, expr_ptr);
16044                         expr_ptr = new_expr;
16045                 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
16046                         zval *new_expr;
16047 
16048                         ALLOC_ZVAL(new_expr);
16049                         INIT_PZVAL_COPY(new_expr, expr_ptr);
16050                         expr_ptr = new_expr;
16051                         zendi_zval_copy_ctor(*expr_ptr);
16052                         zval_ptr_dtor_nogc(&free_op1.var);
16053                 } else if (IS_VAR == IS_CV) {
16054                         Z_ADDREF_P(expr_ptr);
16055                 }
16056         }
16057 
16058         if (IS_CONST != IS_UNUSED) {
16059 
16060                 zval *offset = opline->op2.zv;
16061                 ulong hval;
16062 
16063                 switch (Z_TYPE_P(offset)) {
16064                         case IS_DOUBLE:
16065                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
16066                                 goto num_index;
16067                         case IS_LONG:
16068                         case IS_BOOL:
16069                                 hval = Z_LVAL_P(offset);
16070 num_index:
16071                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
16072                                 break;
16073                         case IS_STRING:
16074                                 if (IS_CONST == IS_CONST) {
16075                                         hval = Z_HASH_P(offset);
16076                                 } else {
16077                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
16078                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
16079                                 }
16080                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
16081                                 break;
16082                         case IS_NULL:
16083                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
16084                                 break;
16085                         default:
16086                                 zend_error(E_WARNING, "Illegal offset type");
16087                                 zval_ptr_dtor(&expr_ptr);
16088                                 /* do nothing */
16089                                 break;
16090                 }
16091 
16092         } else {
16093                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
16094         }
16095         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
16096                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
16097         }
16098         CHECK_EXCEPTION();
16099         ZEND_VM_NEXT_OPCODE();
16100 }
16101 
16102 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16103 {
16104         USE_OPLINE
16105 
16106         array_init(&EX_T(opline->result.var).tmp_var);
16107         if (IS_VAR == IS_UNUSED) {
16108                 ZEND_VM_NEXT_OPCODE();
16109 #if 0 || IS_VAR != IS_UNUSED
16110         } else {
16111                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16112 #endif
16113         }
16114 }
16115 
16116 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16117 {
16118         USE_OPLINE
16119         zval tmp, *varname;
16120         HashTable *target_symbol_table;
16121         zend_free_op free_op1;
16122 
16123         SAVE_OPLINE();
16124         if (IS_VAR == IS_CV &&
16125             IS_CONST == IS_UNUSED &&
16126             (opline->extended_value & ZEND_QUICK_SET)) {
16127                 if (EG(active_symbol_table)) {
16128                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
16129 
16130                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
16131                         EX_CV(opline->op1.var) = NULL;
16132                 } else if (EX_CV(opline->op1.var)) {
16133                         zval_ptr_dtor(EX_CV(opline->op1.var));
16134                         EX_CV(opline->op1.var) = NULL;
16135                 }
16136                 CHECK_EXCEPTION();
16137                 ZEND_VM_NEXT_OPCODE();
16138         }
16139 
16140         varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16141 
16142         if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
16143                 ZVAL_COPY_VALUE(&tmp, varname);
16144                 zval_copy_ctor(&tmp);
16145                 convert_to_string(&tmp);
16146                 varname = &tmp;
16147         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
16148                 Z_ADDREF_P(varname);
16149         }
16150 
16151         if (IS_CONST != IS_UNUSED) {
16152                 zend_class_entry *ce;
16153 
16154                 if (IS_CONST == IS_CONST) {
16155                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
16156                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
16157                         } else {
16158                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
16159                                 if (UNEXPECTED(EG(exception) != NULL)) {
16160                                         if (IS_VAR != IS_CONST && varname == &tmp) {
16161                                                 zval_dtor(&tmp);
16162                                         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
16163                                                 zval_ptr_dtor(&varname);
16164                                         }
16165                                         zval_ptr_dtor_nogc(&free_op1.var);
16166                                         HANDLE_EXCEPTION();
16167                                 }
16168                                 if (UNEXPECTED(ce == NULL)) {
16169                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
16170                                 }
16171                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
16172                         }
16173                 } else {
16174                         ce = EX_T(opline->op2.var).class_entry;
16175                 }
16176                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
16177         } else {
16178                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
16179 
16180                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
16181                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
16182         }
16183 
16184         if (IS_VAR != IS_CONST && varname == &tmp) {
16185                 zval_dtor(&tmp);
16186         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
16187                 zval_ptr_dtor(&varname);
16188         }
16189         zval_ptr_dtor_nogc(&free_op1.var);
16190         CHECK_EXCEPTION();
16191         ZEND_VM_NEXT_OPCODE();
16192 }
16193 
16194 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16195 {
16196         USE_OPLINE
16197         zend_free_op free_op1;
16198         zval **container;
16199         zval *offset;
16200         ulong hval;
16201 
16202         SAVE_OPLINE();
16203         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16204         if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
16205                 SEPARATE_ZVAL_IF_NOT_REF(container);
16206         }
16207         offset = opline->op2.zv;
16208 
16209         if (IS_VAR != IS_VAR || container) {
16210                 switch (Z_TYPE_PP(container)) {
16211                         case IS_ARRAY: {
16212                                 HashTable *ht = Z_ARRVAL_PP(container);
16213 
16214                                 switch (Z_TYPE_P(offset)) {
16215                                         case IS_DOUBLE:
16216                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
16217                                                 zend_hash_index_del(ht, hval);
16218                                                 break;
16219                                         case IS_RESOURCE:
16220                                         case IS_BOOL:
16221                                         case IS_LONG:
16222                                                 hval = Z_LVAL_P(offset);
16223                                                 zend_hash_index_del(ht, hval);
16224                                                 break;
16225                                         case IS_STRING:
16226                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
16227                                                         Z_ADDREF_P(offset);
16228                                                 }
16229                                                 if (IS_CONST == IS_CONST) {
16230                                                         hval = Z_HASH_P(offset);
16231                                                 } else {
16232                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
16233                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
16234                                                 }
16235                                                 if (ht == &EG(symbol_table)) {
16236                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
16237                                                 } else {
16238                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
16239                                                 }
16240                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
16241                                                         zval_ptr_dtor(&offset);
16242                                                 }
16243                                                 break;
16244 num_index_dim:
16245                                                 zend_hash_index_del(ht, hval);
16246                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
16247                                                         zval_ptr_dtor(&offset);
16248                                                 }
16249                                                 break;
16250                                         case IS_NULL:
16251                                                 zend_hash_del(ht, "", sizeof(""));
16252                                                 break;
16253                                         default:
16254                                                 zend_error(E_WARNING, "Illegal offset type in unset");
16255                                                 break;
16256                                 }
16257 
16258                                 break;
16259                         }
16260                         case IS_OBJECT:
16261                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
16262                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
16263                                 }
16264                                 if (0) {
16265                                         MAKE_REAL_ZVAL_PTR(offset);
16266                                 }
16267                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
16268                                 if (0) {
16269                                         zval_ptr_dtor(&offset);
16270                                 } else {
16271 
16272                                 }
16273                                 break;
16274                         case IS_STRING:
16275                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
16276                                 ZEND_VM_CONTINUE(); /* bailed out before */
16277                         default:
16278 
16279                                 break;
16280                 }
16281         } else {
16282 
16283         }
16284         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
16285 
16286         CHECK_EXCEPTION();
16287         ZEND_VM_NEXT_OPCODE();
16288 }
16289 
16290 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16291 {
16292         USE_OPLINE
16293         zend_free_op free_op1;
16294         zval **container;
16295         zval *offset;
16296 
16297         SAVE_OPLINE();
16298         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16299         offset = opline->op2.zv;
16300 
16301         if (IS_VAR != IS_VAR || container) {
16302                 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
16303                         SEPARATE_ZVAL_IF_NOT_REF(container);
16304                 }
16305                 if (Z_TYPE_PP(container) == IS_OBJECT) {
16306                         if (0) {
16307                                 MAKE_REAL_ZVAL_PTR(offset);
16308                         }
16309                         if (Z_OBJ_HT_P(*container)->unset_property) {
16310                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
16311                         } else {
16312                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
16313                         }
16314                         if (0) {
16315                                 zval_ptr_dtor(&offset);
16316                         } else {
16317 
16318                         }
16319                 } else {
16320 
16321                 }
16322         } else {
16323 
16324         }
16325         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
16326 
16327         CHECK_EXCEPTION();
16328         ZEND_VM_NEXT_OPCODE();
16329 }
16330 
16331 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16332 {
16333         USE_OPLINE
16334         zval **value;
16335         zend_bool isset = 1;
16336 
16337         SAVE_OPLINE();
16338         if (IS_VAR == IS_CV &&
16339             IS_CONST == IS_UNUSED &&
16340             (opline->extended_value & ZEND_QUICK_SET)) {
16341                 if (EX_CV(opline->op1.var)) {
16342                         value = EX_CV(opline->op1.var);
16343                 } else if (EG(active_symbol_table)) {
16344                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
16345 
16346                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
16347                                 isset = 0;
16348                         }
16349                 } else {
16350                         isset = 0;
16351                 }
16352         } else {
16353                 HashTable *target_symbol_table;
16354                 zend_free_op free_op1;
16355                 zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16356 
16357                 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
16358                         ZVAL_COPY_VALUE(&tmp, varname);
16359                         zval_copy_ctor(&tmp);
16360                         convert_to_string(&tmp);
16361                         varname = &tmp;
16362                 }
16363 
16364                 if (IS_CONST != IS_UNUSED) {
16365                         zend_class_entry *ce;
16366 
16367                         if (IS_CONST == IS_CONST) {
16368                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
16369                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
16370                                 } else {
16371                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
16372                                         if (UNEXPECTED(ce == NULL)) {
16373                                                 CHECK_EXCEPTION();
16374                                                 ZEND_VM_NEXT_OPCODE();
16375                                         }
16376                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
16377                                 }
16378                         } else {
16379                                 ce = EX_T(opline->op2.var).class_entry;
16380                         }
16381                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
16382                         if (!value) {
16383                                 isset = 0;
16384                         }
16385                 } else {
16386                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
16387                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
16388                                 isset = 0;
16389                         }
16390                 }
16391 
16392                 if (IS_VAR != IS_CONST && varname == &tmp) {
16393                         zval_dtor(&tmp);
16394                 }
16395                 zval_ptr_dtor_nogc(&free_op1.var);
16396         }
16397 
16398         if (opline->extended_value & ZEND_ISSET) {
16399                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
16400                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
16401                 } else {
16402                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
16403                 }
16404         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
16405                 if (!isset || !i_zend_is_true(*value)) {
16406                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
16407                 } else {
16408                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
16409                 }
16410         }
16411 
16412         CHECK_EXCEPTION();
16413         ZEND_VM_NEXT_OPCODE();
16414 }
16415 
16416 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
16417 {
16418         USE_OPLINE
16419         zend_free_op free_op1;
16420         zval *container;
16421         zval **value = NULL;
16422         int result = 0;
16423         ulong hval;
16424         zval *offset;
16425 
16426         SAVE_OPLINE();
16427         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16428         offset = opline->op2.zv;
16429 
16430         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
16431                 HashTable *ht;
16432                 int isset = 0;
16433 
16434                 ht = Z_ARRVAL_P(container);
16435 
16436                 switch (Z_TYPE_P(offset)) {
16437                         case IS_DOUBLE:
16438                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
16439                                 goto num_index_prop;
16440                         case IS_RESOURCE:
16441                         case IS_BOOL:
16442                         case IS_LONG:
16443                                 hval = Z_LVAL_P(offset);
16444 num_index_prop:
16445                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
16446                                         isset = 1;
16447                                 }
16448                                 break;
16449                         case IS_STRING:
16450                                 if (IS_CONST == IS_CONST) {
16451                                         hval = Z_HASH_P(offset);
16452                                 } else {
16453                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
16454                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
16455                                 }
16456                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
16457                                         isset = 1;
16458                                 }
16459                                 break;
16460                         case IS_NULL:
16461                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
16462                                         isset = 1;
16463                                 }
16464                                 break;
16465                         default:
16466                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
16467                                 break;
16468                 }
16469 
16470                 if (opline->extended_value & ZEND_ISSET) {
16471                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
16472                                 result = 0;
16473                         } else {
16474                                 result = isset;
16475                         }
16476                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
16477                         if (!isset || !i_zend_is_true(*value)) {
16478                                 result = 0;
16479                         } else {
16480                                 result = 1;
16481                         }
16482                 }
16483 
16484         } else if (Z_TYPE_P(container) == IS_OBJECT) {
16485                 if (0) {
16486                         MAKE_REAL_ZVAL_PTR(offset);
16487                 }
16488                 if (prop_dim) {
16489                         if (Z_OBJ_HT_P(container)->has_property) {
16490                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
16491                         } else {
16492                                 zend_error(E_NOTICE, "Trying to check property of non-object");
16493                                 result = 0;
16494                         }
16495                 } else {
16496                         if (Z_OBJ_HT_P(container)->has_dimension) {
16497                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
16498                         } else {
16499                                 zend_error(E_NOTICE, "Trying to check element of non-array");
16500                                 result = 0;
16501                         }
16502                 }
16503                 if (0) {
16504                         zval_ptr_dtor(&offset);
16505                 } else {
16506 
16507                 }
16508         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
16509                 zval tmp;
16510 
16511                 if (Z_TYPE_P(offset) != IS_LONG) {
16512                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
16513                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
16514                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
16515                                 ZVAL_COPY_VALUE(&tmp, offset);
16516                                 zval_copy_ctor(&tmp);
16517                                 convert_to_long(&tmp);
16518                                 offset = &tmp;
16519                         } else {
16520                                 /* can not be converted to proper offset, return "not set" */
16521                                 result = 0;
16522                         }
16523                 }
16524                 if (Z_TYPE_P(offset) == IS_LONG) {
16525                         if (opline->extended_value & ZEND_ISSET) {
16526                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
16527                                         result = 1;
16528                                 }
16529                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
16530                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
16531                                         result = 1;
16532                                 }
16533                         }
16534                 }
16535 
16536         } else {
16537 
16538         }
16539 
16540         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
16541         if (opline->extended_value & ZEND_ISSET) {
16542                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
16543         } else {
16544                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
16545         }
16546 
16547         zval_ptr_dtor_nogc(&free_op1.var);
16548 
16549         CHECK_EXCEPTION();
16550         ZEND_VM_NEXT_OPCODE();
16551 }
16552 
16553 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16554 {
16555         return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16556 }
16557 
16558 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16559 {
16560         return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16561 }
16562 
16563 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16564 {
16565         USE_OPLINE
16566 
16567         /* The generator object is stored in return_value_ptr_ptr */
16568         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
16569 
16570         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
16571                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
16572         }
16573 
16574         /* Destroy the previously yielded value */
16575         if (generator->value) {
16576                 zval_ptr_dtor(&generator->value);
16577         }
16578 
16579         /* Destroy the previously yielded key */
16580         if (generator->key) {
16581                 zval_ptr_dtor(&generator->key);
16582         }
16583 
16584         /* Set the new yielded value */
16585         if (IS_VAR != IS_UNUSED) {
16586                 zend_free_op free_op1;
16587 
16588                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
16589                         /* Constants and temporary variables aren't yieldable by reference,
16590                          * but we still allow them with a notice. */
16591                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
16592                                 zval *value, *copy;
16593 
16594                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
16595 
16596                                 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16597                                 ALLOC_ZVAL(copy);
16598                                 INIT_PZVAL_COPY(copy, value);
16599 
16600                                 /* Temporary variables don't need ctor copying */
16601                                 if (!0) {
16602                                         zval_copy_ctor(copy);
16603                                 }
16604 
16605                                 generator->value = copy;
16606                         } else {
16607                                 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16608 
16609                                 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
16610                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
16611                                 }
16612 
16613                                 /* If a function call result is yielded and the function did
16614                                  * not return by reference we throw a notice. */
16615                                 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
16616                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
16617                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
16618                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
16619                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
16620 
16621                                         Z_ADDREF_PP(value_ptr);
16622                                         generator->value = *value_ptr;
16623                                 } else {
16624                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
16625                                         Z_ADDREF_PP(value_ptr);
16626                                         generator->value = *value_ptr;
16627                                 }
16628 
16629                                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
16630                         }
16631                 } else {
16632                         zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
16633 
16634                         /* Consts, temporary variables and references need copying */
16635                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
16636                                 || PZVAL_IS_REF(value)
16637                         ) {
16638                                 zval *copy;
16639 
16640                                 ALLOC_ZVAL(copy);
16641                                 INIT_PZVAL_COPY(copy, value);
16642 
16643                                 /* Temporary variables don't need ctor copying */
16644                                 if (!0) {
16645                                         zval_copy_ctor(copy);
16646                                 }
16647 
16648                                 generator->value = copy;
16649                                 zval_ptr_dtor_nogc(&free_op1.var);
16650                         } else {
16651                                 if (IS_VAR == IS_CV) {
16652                                         Z_ADDREF_P(value);
16653                                 }
16654                                 generator->value = value;
16655                         }
16656                 }
16657         } else {
16658                 /* If no value was specified yield null */
16659                 Z_ADDREF(EG(uninitialized_zval));
16660                 generator->value = &EG(uninitialized_zval);
16661         }
16662 
16663         /* Set the new yielded key */
16664         if (IS_CONST != IS_UNUSED) {
16665 
16666                 zval *key = opline->op2.zv;
16667 
16668                 /* Consts, temporary variables and references need copying */
16669                 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
16670                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
16671                 ) {
16672                         zval *copy;
16673 
16674                         ALLOC_ZVAL(copy);
16675                         INIT_PZVAL_COPY(copy, key);
16676 
16677                         /* Temporary variables don't need ctor copying */
16678                         if (!0) {
16679                                 zval_copy_ctor(copy);
16680                         }
16681 
16682                         generator->key = copy;
16683                 } else {
16684                         Z_ADDREF_P(key);
16685                         generator->key = key;
16686                 }
16687 
16688                 if (Z_TYPE_P(generator->key) == IS_LONG
16689                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
16690                 ) {
16691                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
16692                 }
16693 
16694         } else {
16695                 /* If no key was specified we use auto-increment keys */
16696                 generator->largest_used_integer_key++;
16697 
16698                 ALLOC_INIT_ZVAL(generator->key);
16699                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
16700         }
16701 
16702         if (RETURN_VALUE_USED(opline)) {
16703                 /* If the return value of yield is used set the send
16704                  * target and initialize it to NULL */
16705                 generator->send_target = &EX_T(opline->result.var).var.ptr;
16706                 Z_ADDREF(EG(uninitialized_zval));
16707                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
16708         } else {
16709                 generator->send_target = NULL;
16710         }
16711 
16712         /* We increment to the next op, so we are at the correct position when the
16713          * generator is resumed. */
16714         ZEND_VM_INC_OPCODE();
16715 
16716         /* The GOTO VM uses a local opline variable. We need to set the opline
16717          * variable in execute_data so we don't resume at an old position. */
16718         SAVE_OPLINE();
16719 
16720         ZEND_VM_RETURN();
16721 }
16722 
16723 static int ZEND_FASTCALL  ZEND_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16724 {
16725         USE_OPLINE
16726         zend_free_op free_op1;
16727 
16728         SAVE_OPLINE();
16729         pow_function(&EX_T(opline->result.var).tmp_var,
16730                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16731                 opline->op2.zv TSRMLS_CC);
16732         zval_ptr_dtor_nogc(&free_op1.var);
16733 
16734         CHECK_EXCEPTION();
16735         ZEND_VM_NEXT_OPCODE();
16736 }
16737 
16738 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16739 {
16740         return zend_binary_assign_op_helper_SPEC_VAR_CONST(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
16741 }
16742 
16743 static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16744 {
16745         USE_OPLINE
16746         zend_free_op free_op1, free_op2;
16747 
16748         SAVE_OPLINE();
16749         fast_add_function(&EX_T(opline->result.var).tmp_var,
16750                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16751                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16752         zval_ptr_dtor_nogc(&free_op1.var);
16753         zval_dtor(free_op2.var);
16754         CHECK_EXCEPTION();
16755         ZEND_VM_NEXT_OPCODE();
16756 }
16757 
16758 static int ZEND_FASTCALL  ZEND_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16759 {
16760         USE_OPLINE
16761         zend_free_op free_op1, free_op2;
16762 
16763         SAVE_OPLINE();
16764         fast_sub_function(&EX_T(opline->result.var).tmp_var,
16765                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16766                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16767         zval_ptr_dtor_nogc(&free_op1.var);
16768         zval_dtor(free_op2.var);
16769         CHECK_EXCEPTION();
16770         ZEND_VM_NEXT_OPCODE();
16771 }
16772 
16773 static int ZEND_FASTCALL  ZEND_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16774 {
16775         USE_OPLINE
16776         zend_free_op free_op1, free_op2;
16777 
16778         SAVE_OPLINE();
16779         fast_mul_function(&EX_T(opline->result.var).tmp_var,
16780                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16781                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16782         zval_ptr_dtor_nogc(&free_op1.var);
16783         zval_dtor(free_op2.var);
16784         CHECK_EXCEPTION();
16785         ZEND_VM_NEXT_OPCODE();
16786 }
16787 
16788 static int ZEND_FASTCALL  ZEND_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16789 {
16790         USE_OPLINE
16791         zend_free_op free_op1, free_op2;
16792 
16793         SAVE_OPLINE();
16794         fast_div_function(&EX_T(opline->result.var).tmp_var,
16795                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16796                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16797         zval_ptr_dtor_nogc(&free_op1.var);
16798         zval_dtor(free_op2.var);
16799         CHECK_EXCEPTION();
16800         ZEND_VM_NEXT_OPCODE();
16801 }
16802 
16803 static int ZEND_FASTCALL  ZEND_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16804 {
16805         USE_OPLINE
16806         zend_free_op free_op1, free_op2;
16807 
16808         SAVE_OPLINE();
16809         fast_mod_function(&EX_T(opline->result.var).tmp_var,
16810                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16811                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16812         zval_ptr_dtor_nogc(&free_op1.var);
16813         zval_dtor(free_op2.var);
16814         CHECK_EXCEPTION();
16815         ZEND_VM_NEXT_OPCODE();
16816 }
16817 
16818 static int ZEND_FASTCALL  ZEND_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16819 {
16820         USE_OPLINE
16821         zend_free_op free_op1, free_op2;
16822 
16823         SAVE_OPLINE();
16824         shift_left_function(&EX_T(opline->result.var).tmp_var,
16825                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16826                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16827         zval_ptr_dtor_nogc(&free_op1.var);
16828         zval_dtor(free_op2.var);
16829         CHECK_EXCEPTION();
16830         ZEND_VM_NEXT_OPCODE();
16831 }
16832 
16833 static int ZEND_FASTCALL  ZEND_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16834 {
16835         USE_OPLINE
16836         zend_free_op free_op1, free_op2;
16837 
16838         SAVE_OPLINE();
16839         shift_right_function(&EX_T(opline->result.var).tmp_var,
16840                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16841                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16842         zval_ptr_dtor_nogc(&free_op1.var);
16843         zval_dtor(free_op2.var);
16844         CHECK_EXCEPTION();
16845         ZEND_VM_NEXT_OPCODE();
16846 }
16847 
16848 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16849 {
16850         USE_OPLINE
16851         zend_free_op free_op1, free_op2;
16852 
16853         SAVE_OPLINE();
16854         concat_function(&EX_T(opline->result.var).tmp_var,
16855                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16856                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16857         zval_ptr_dtor_nogc(&free_op1.var);
16858         zval_dtor(free_op2.var);
16859         CHECK_EXCEPTION();
16860         ZEND_VM_NEXT_OPCODE();
16861 }
16862 
16863 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16864 {
16865         USE_OPLINE
16866         zend_free_op free_op1, free_op2;
16867 
16868         SAVE_OPLINE();
16869         is_identical_function(&EX_T(opline->result.var).tmp_var,
16870                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16871                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16872         zval_ptr_dtor_nogc(&free_op1.var);
16873         zval_dtor(free_op2.var);
16874         CHECK_EXCEPTION();
16875         ZEND_VM_NEXT_OPCODE();
16876 }
16877 
16878 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16879 {
16880         USE_OPLINE
16881         zend_free_op free_op1, free_op2;
16882         zval *result = &EX_T(opline->result.var).tmp_var;
16883 
16884         SAVE_OPLINE();
16885         is_identical_function(result,
16886                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16887                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16888         Z_LVAL_P(result) = !Z_LVAL_P(result);
16889         zval_ptr_dtor_nogc(&free_op1.var);
16890         zval_dtor(free_op2.var);
16891         CHECK_EXCEPTION();
16892         ZEND_VM_NEXT_OPCODE();
16893 }
16894 
16895 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16896 {
16897         USE_OPLINE
16898         zend_free_op free_op1, free_op2;
16899         zval *result = &EX_T(opline->result.var).tmp_var;
16900 
16901         SAVE_OPLINE();
16902         ZVAL_BOOL(result, fast_equal_function(result,
16903                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16904                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
16905         zval_ptr_dtor_nogc(&free_op1.var);
16906         zval_dtor(free_op2.var);
16907         CHECK_EXCEPTION();
16908         ZEND_VM_NEXT_OPCODE();
16909 }
16910 
16911 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16912 {
16913         USE_OPLINE
16914         zend_free_op free_op1, free_op2;
16915         zval *result = &EX_T(opline->result.var).tmp_var;
16916 
16917         SAVE_OPLINE();
16918         ZVAL_BOOL(result, fast_not_equal_function(result,
16919                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16920                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
16921         zval_ptr_dtor_nogc(&free_op1.var);
16922         zval_dtor(free_op2.var);
16923         CHECK_EXCEPTION();
16924         ZEND_VM_NEXT_OPCODE();
16925 }
16926 
16927 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16928 {
16929         USE_OPLINE
16930         zend_free_op free_op1, free_op2;
16931         zval *result = &EX_T(opline->result.var).tmp_var;
16932 
16933         SAVE_OPLINE();
16934         ZVAL_BOOL(result, fast_is_smaller_function(result,
16935                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16936                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
16937         zval_ptr_dtor_nogc(&free_op1.var);
16938         zval_dtor(free_op2.var);
16939         CHECK_EXCEPTION();
16940         ZEND_VM_NEXT_OPCODE();
16941 }
16942 
16943 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16944 {
16945         USE_OPLINE
16946         zend_free_op free_op1, free_op2;
16947         zval *result = &EX_T(opline->result.var).tmp_var;
16948 
16949         SAVE_OPLINE();
16950         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
16951                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16952                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
16953         zval_ptr_dtor_nogc(&free_op1.var);
16954         zval_dtor(free_op2.var);
16955         CHECK_EXCEPTION();
16956         ZEND_VM_NEXT_OPCODE();
16957 }
16958 
16959 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16960 {
16961         USE_OPLINE
16962         zend_free_op free_op1, free_op2;
16963 
16964         SAVE_OPLINE();
16965         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
16966                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16967                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16968         zval_ptr_dtor_nogc(&free_op1.var);
16969         zval_dtor(free_op2.var);
16970         CHECK_EXCEPTION();
16971         ZEND_VM_NEXT_OPCODE();
16972 }
16973 
16974 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16975 {
16976         USE_OPLINE
16977         zend_free_op free_op1, free_op2;
16978 
16979         SAVE_OPLINE();
16980         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
16981                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16982                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16983         zval_ptr_dtor_nogc(&free_op1.var);
16984         zval_dtor(free_op2.var);
16985         CHECK_EXCEPTION();
16986         ZEND_VM_NEXT_OPCODE();
16987 }
16988 
16989 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16990 {
16991         USE_OPLINE
16992         zend_free_op free_op1, free_op2;
16993 
16994         SAVE_OPLINE();
16995         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
16996                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
16997                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
16998         zval_ptr_dtor_nogc(&free_op1.var);
16999         zval_dtor(free_op2.var);
17000         CHECK_EXCEPTION();
17001         ZEND_VM_NEXT_OPCODE();
17002 }
17003 
17004 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17005 {
17006         USE_OPLINE
17007         zend_free_op free_op1, free_op2;
17008 
17009         SAVE_OPLINE();
17010         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
17011                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
17012                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
17013         zval_ptr_dtor_nogc(&free_op1.var);
17014         zval_dtor(free_op2.var);
17015         CHECK_EXCEPTION();
17016         ZEND_VM_NEXT_OPCODE();
17017 }
17018 
17019 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
17020 {
17021         USE_OPLINE
17022         zend_free_op free_op1, free_op2, free_op_data1;
17023         zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17024         zval *object;
17025         zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17026         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
17027         int have_get_ptr = 0;
17028 
17029         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17030                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17031         }
17032 
17033         make_real_object(object_ptr TSRMLS_CC);
17034         object = *object_ptr;
17035 
17036         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
17037                 zend_error(E_WARNING, "Attempt to assign property of non-object");
17038                 zval_dtor(free_op2.var);
17039                 FREE_OP(free_op_data1);
17040 
17041                 if (RETURN_VALUE_USED(opline)) {
17042                         PZVAL_LOCK(&EG(uninitialized_zval));
17043                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17044                 }
17045         } else {
17046                 /* here we are sure we are dealing with an object */
17047                 if (1) {
17048                         MAKE_REAL_ZVAL_PTR(property);
17049                 }
17050 
17051                 /* here property is a string */
17052                 if (opline->extended_value == ZEND_ASSIGN_OBJ
17053                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17054                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17055                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
17056                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
17057 
17058                                 have_get_ptr = 1;
17059                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
17060                                 if (RETURN_VALUE_USED(opline)) {
17061                                         PZVAL_LOCK(*zptr);
17062                                         EX_T(opline->result.var).var.ptr = *zptr;
17063                                 }
17064                         }
17065                 }
17066 
17067                 if (!have_get_ptr) {
17068                         zval *z = NULL;
17069 
17070                         Z_ADDREF_P(object);
17071                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
17072                                 if (Z_OBJ_HT_P(object)->read_property) {
17073                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17074                                 }
17075                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
17076                                 if (Z_OBJ_HT_P(object)->read_dimension) {
17077                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
17078                                 }
17079                         }
17080                         if (z) {
17081                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
17082                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17083 
17084                                         if (Z_REFCOUNT_P(z) == 0) {
17085                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
17086                                                 zval_dtor(z);
17087                                                 FREE_ZVAL(z);
17088                                         }
17089                                         z = value;
17090                                 }
17091                                 Z_ADDREF_P(z);
17092                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
17093                                 binary_op(z, z, value TSRMLS_CC);
17094                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
17095                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17096                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
17097                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
17098                                 }
17099                                 if (RETURN_VALUE_USED(opline)) {
17100                                         PZVAL_LOCK(z);
17101                                         EX_T(opline->result.var).var.ptr = z;
17102                                 }
17103                                 zval_ptr_dtor(&z);
17104                         } else {
17105                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
17106                                 if (RETURN_VALUE_USED(opline)) {
17107                                         PZVAL_LOCK(&EG(uninitialized_zval));
17108                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17109                                 }
17110                         }
17111                         zval_ptr_dtor(&object);
17112                 }
17113 
17114                 if (1) {
17115                         zval_ptr_dtor(&property);
17116                 } else {
17117                         zval_dtor(free_op2.var);
17118                 }
17119                 FREE_OP(free_op_data1);
17120         }
17121 
17122         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17123         /* assign_obj has two opcodes! */
17124         CHECK_EXCEPTION();
17125         ZEND_VM_INC_OPCODE();
17126         ZEND_VM_NEXT_OPCODE();
17127 }
17128 
17129 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
17130 {
17131         USE_OPLINE
17132         zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
17133         zval **var_ptr;
17134         zval *value;
17135 
17136         SAVE_OPLINE();
17137         switch (opline->extended_value) {
17138                 case ZEND_ASSIGN_OBJ:
17139                         return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17140                         break;
17141                 case ZEND_ASSIGN_DIM: {
17142                                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17143 
17144                                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17145                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17146                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
17147                                         if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
17148                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
17149                                         }
17150                                         return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17151                                 } else {
17152                                         zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17153 
17154                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
17155                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
17156                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
17157                                 }
17158                         }
17159                         break;
17160                 default:
17161                         value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17162                         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17163                         /* do nothing */
17164                         break;
17165         }
17166 
17167         if (UNEXPECTED(var_ptr == NULL)) {
17168                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
17169         }
17170 
17171         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
17172                 if (RETURN_VALUE_USED(opline)) {
17173                         PZVAL_LOCK(&EG(uninitialized_zval));
17174                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17175                 }
17176                 zval_dtor(free_op2.var);
17177                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17178                 CHECK_EXCEPTION();
17179                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
17180                         ZEND_VM_INC_OPCODE();
17181                 }
17182                 ZEND_VM_NEXT_OPCODE();
17183         }
17184 
17185         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
17186 
17187         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
17188            && Z_OBJ_HANDLER_PP(var_ptr, get)
17189            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
17190                 /* proxy object */
17191                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
17192                 Z_ADDREF_P(objval);
17193                 binary_op(objval, objval, value TSRMLS_CC);
17194                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
17195                 zval_ptr_dtor(&objval);
17196         } else {
17197                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
17198         }
17199 
17200         if (RETURN_VALUE_USED(opline)) {
17201                 PZVAL_LOCK(*var_ptr);
17202                 EX_T(opline->result.var).var.ptr = *var_ptr;
17203         }
17204         zval_dtor(free_op2.var);
17205 
17206         if (opline->extended_value == ZEND_ASSIGN_DIM) {
17207                 FREE_OP(free_op_data1);
17208                 FREE_OP_VAR_PTR(free_op_data2);
17209                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17210                 CHECK_EXCEPTION();
17211                 ZEND_VM_INC_OPCODE();
17212         } else {
17213                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17214                 CHECK_EXCEPTION();
17215         }
17216         ZEND_VM_NEXT_OPCODE();
17217 }
17218 
17219 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17220 {
17221         return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17222 }
17223 
17224 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17225 {
17226         return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17227 }
17228 
17229 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17230 {
17231         return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17232 }
17233 
17234 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17235 {
17236         return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17237 }
17238 
17239 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17240 {
17241         return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17242 }
17243 
17244 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17245 {
17246         return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17247 }
17248 
17249 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17250 {
17251         return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17252 }
17253 
17254 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17255 {
17256         return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17257 }
17258 
17259 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17260 {
17261         return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17262 }
17263 
17264 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17265 {
17266         return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17267 }
17268 
17269 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17270 {
17271         return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17272 }
17273 
17274 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
17275 {
17276         USE_OPLINE
17277         zend_free_op free_op1, free_op2;
17278         zval **object_ptr;
17279         zval *object;
17280         zval *property;
17281         zval **retval;
17282         int have_get_ptr = 0;
17283 
17284         SAVE_OPLINE();
17285         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17286         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17287         retval = &EX_T(opline->result.var).var.ptr;
17288 
17289         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17290                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
17291         }
17292 
17293         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
17294         object = *object_ptr;
17295 
17296         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
17297                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17298                 zval_dtor(free_op2.var);
17299                 if (RETURN_VALUE_USED(opline)) {
17300                         PZVAL_LOCK(&EG(uninitialized_zval));
17301                         *retval = &EG(uninitialized_zval);
17302                 }
17303                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17304                 CHECK_EXCEPTION();
17305                 ZEND_VM_NEXT_OPCODE();
17306         }
17307 
17308         /* here we are sure we are dealing with an object */
17309 
17310         if (1) {
17311                 MAKE_REAL_ZVAL_PTR(property);
17312         }
17313 
17314         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17315                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17316                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
17317                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
17318 
17319                         have_get_ptr = 1;
17320                         incdec_op(*zptr);
17321                         if (RETURN_VALUE_USED(opline)) {
17322                                 *retval = *zptr;
17323                                 PZVAL_LOCK(*retval);
17324                         }
17325                 }
17326         }
17327 
17328         if (!have_get_ptr) {
17329                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
17330                         zval *z;
17331 
17332                         Z_ADDREF_P(object);
17333                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17334 
17335                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
17336                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17337 
17338                                 if (Z_REFCOUNT_P(z) == 0) {
17339                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
17340                                         zval_dtor(z);
17341                                         FREE_ZVAL(z);
17342                                 }
17343                                 z = value;
17344                         }
17345                         Z_ADDREF_P(z);
17346                         SEPARATE_ZVAL_IF_NOT_REF(&z);
17347                         incdec_op(z);
17348                         *retval = z;
17349                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17350                         zval_ptr_dtor(&object);
17351                         SELECTIVE_PZVAL_LOCK(*retval, opline);
17352                         zval_ptr_dtor(&z);
17353                 } else {
17354                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17355                         if (RETURN_VALUE_USED(opline)) {
17356                                 PZVAL_LOCK(&EG(uninitialized_zval));
17357                                 *retval = &EG(uninitialized_zval);
17358                         }
17359                 }
17360         }
17361 
17362         if (1) {
17363                 zval_ptr_dtor(&property);
17364         } else {
17365                 zval_dtor(free_op2.var);
17366         }
17367         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17368         CHECK_EXCEPTION();
17369         ZEND_VM_NEXT_OPCODE();
17370 }
17371 
17372 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17373 {
17374         return zend_pre_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17375 }
17376 
17377 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17378 {
17379         return zend_pre_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17380 }
17381 
17382 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
17383 {
17384         USE_OPLINE
17385         zend_free_op free_op1, free_op2;
17386         zval **object_ptr;
17387         zval *object;
17388         zval *property;
17389         zval *retval;
17390         int have_get_ptr = 0;
17391 
17392         SAVE_OPLINE();
17393         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17394         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17395         retval = &EX_T(opline->result.var).tmp_var;
17396 
17397         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17398                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
17399         }
17400 
17401         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
17402         object = *object_ptr;
17403 
17404         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
17405                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17406                 zval_dtor(free_op2.var);
17407                 ZVAL_NULL(retval);
17408                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17409                 CHECK_EXCEPTION();
17410                 ZEND_VM_NEXT_OPCODE();
17411         }
17412 
17413         /* here we are sure we are dealing with an object */
17414 
17415         if (1) {
17416                 MAKE_REAL_ZVAL_PTR(property);
17417         }
17418 
17419         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
17420                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17421                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
17422                         have_get_ptr = 1;
17423                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
17424 
17425                         ZVAL_COPY_VALUE(retval, *zptr);
17426                         zendi_zval_copy_ctor(*retval);
17427 
17428                         incdec_op(*zptr);
17429 
17430                 }
17431         }
17432 
17433         if (!have_get_ptr) {
17434                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
17435                         zval *z, *z_copy;
17436 
17437                         Z_ADDREF_P(object);
17438                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17439                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
17440                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
17441 
17442                                 if (Z_REFCOUNT_P(z) == 0) {
17443                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
17444                                         zval_dtor(z);
17445                                         FREE_ZVAL(z);
17446                                 }
17447                                 z = value;
17448                         }
17449                         ZVAL_COPY_VALUE(retval, z);
17450                         zendi_zval_copy_ctor(*retval);
17451                         ALLOC_ZVAL(z_copy);
17452                         INIT_PZVAL_COPY(z_copy, z);
17453                         zendi_zval_copy_ctor(*z_copy);
17454                         incdec_op(z_copy);
17455                         Z_ADDREF_P(z);
17456                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17457                         zval_ptr_dtor(&object);
17458                         zval_ptr_dtor(&z_copy);
17459                         zval_ptr_dtor(&z);
17460                 } else {
17461                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
17462                         ZVAL_NULL(retval);
17463                 }
17464         }
17465 
17466         if (1) {
17467                 zval_ptr_dtor(&property);
17468         } else {
17469                 zval_dtor(free_op2.var);
17470         }
17471         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17472         CHECK_EXCEPTION();
17473         ZEND_VM_NEXT_OPCODE();
17474 }
17475 
17476 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17477 {
17478         return zend_post_incdec_property_helper_SPEC_VAR_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17479 }
17480 
17481 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17482 {
17483         return zend_post_incdec_property_helper_SPEC_VAR_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17484 }
17485 
17486 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17487 {
17488         USE_OPLINE
17489         zend_free_op free_op1, free_op2;
17490         zval *container;
17491 
17492         SAVE_OPLINE();
17493         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17494         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
17495         zval_dtor(free_op2.var);
17496         if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
17497                 zval_ptr_dtor_nogc(&free_op1.var);
17498         }
17499         CHECK_EXCEPTION();
17500         ZEND_VM_NEXT_OPCODE();
17501 }
17502 
17503 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17504 {
17505         USE_OPLINE
17506         zend_free_op free_op1, free_op2;
17507         zval **container;
17508 
17509         SAVE_OPLINE();
17510         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17511 
17512         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17513                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17514         }
17515         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
17516         zval_dtor(free_op2.var);
17517         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17518                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17519         }
17520         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17521 
17522         /* We are going to assign the result by reference */
17523         if (UNEXPECTED(opline->extended_value != 0)) {
17524                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
17525 
17526                 if (retval_ptr) {
17527                         Z_DELREF_PP(retval_ptr);
17528                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
17529                         Z_ADDREF_PP(retval_ptr);
17530                 }
17531         }
17532 
17533         CHECK_EXCEPTION();
17534         ZEND_VM_NEXT_OPCODE();
17535 }
17536 
17537 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17538 {
17539         USE_OPLINE
17540         zend_free_op free_op1, free_op2;
17541         zval **container;
17542 
17543         SAVE_OPLINE();
17544         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17545 
17546         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17547                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17548         }
17549         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
17550         zval_dtor(free_op2.var);
17551         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17552                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17553         }
17554         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17555         CHECK_EXCEPTION();
17556         ZEND_VM_NEXT_OPCODE();
17557 }
17558 
17559 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17560 {
17561         USE_OPLINE
17562         zend_free_op free_op1, free_op2;
17563         zval *container;
17564 
17565         SAVE_OPLINE();
17566         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17567         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC);
17568         zval_dtor(free_op2.var);
17569         zval_ptr_dtor_nogc(&free_op1.var);
17570         CHECK_EXCEPTION();
17571         ZEND_VM_NEXT_OPCODE();
17572 }
17573 
17574 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17575 {
17576         USE_OPLINE
17577         zend_free_op free_op1, free_op2;
17578 
17579         SAVE_OPLINE();
17580 
17581         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
17582                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17583                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17584                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17585                 }
17586                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
17587                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17588                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17589                 }
17590                 zval_dtor(free_op2.var);
17591                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17592         } else {
17593                 zval *container;
17594 
17595                 if (IS_TMP_VAR == IS_UNUSED) {
17596                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
17597                 }
17598                 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17599                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
17600                 zval_dtor(free_op2.var);
17601                 zval_ptr_dtor_nogc(&free_op1.var);
17602         }
17603         CHECK_EXCEPTION();
17604         ZEND_VM_NEXT_OPCODE();
17605 }
17606 
17607 static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17608 {
17609         USE_OPLINE
17610         zend_free_op free_op1, free_op2;
17611         zval **container;
17612 
17613         SAVE_OPLINE();
17614         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17615 
17616         if (IS_VAR == IS_CV) {
17617                 if (container != &EG(uninitialized_zval_ptr)) {
17618                         SEPARATE_ZVAL_IF_NOT_REF(container);
17619                 }
17620         }
17621         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17622                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17623         }
17624         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC);
17625         zval_dtor(free_op2.var);
17626         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17627                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17628         }
17629         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17630         if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
17631                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
17632                 ZEND_VM_NEXT_OPCODE();
17633         } else {
17634                 zend_free_op free_res;
17635                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
17636 
17637                 PZVAL_UNLOCK(*retval_ptr, &free_res);
17638                 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
17639                         SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
17640                 }
17641                 PZVAL_LOCK(*retval_ptr);
17642                 FREE_OP_VAR_PTR(free_res);
17643                 CHECK_EXCEPTION();
17644                 ZEND_VM_NEXT_OPCODE();
17645         }
17646 }
17647 
17648 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS)
17649 {
17650         USE_OPLINE
17651         zend_free_op free_op1;
17652         zval *container;
17653         zend_free_op free_op2;
17654         zval *offset;
17655 
17656         SAVE_OPLINE();
17657         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17658         offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17659 
17660         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
17661             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
17662                 zend_error(E_NOTICE, "Trying to get property of non-object");
17663                 PZVAL_LOCK(&EG(uninitialized_zval));
17664                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17665                 zval_dtor(free_op2.var);
17666         } else {
17667                 zval *retval;
17668 
17669                 if (1) {
17670                         MAKE_REAL_ZVAL_PTR(offset);
17671                 }
17672 
17673                 /* here we are sure we are dealing with an object */
17674                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17675 
17676                 PZVAL_LOCK(retval);
17677                 EX_T(opline->result.var).var.ptr = retval;
17678 
17679                 if (1) {
17680                         zval_ptr_dtor(&offset);
17681                 } else {
17682                         zval_dtor(free_op2.var);
17683                 }
17684         }
17685 
17686         zval_ptr_dtor_nogc(&free_op1.var);
17687         CHECK_EXCEPTION();
17688         ZEND_VM_NEXT_OPCODE();
17689 }
17690 
17691 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17692 {
17693         return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17694 }
17695 
17696 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17697 {
17698         USE_OPLINE
17699         zend_free_op free_op1, free_op2;
17700         zval *property;
17701         zval **container;
17702 
17703         SAVE_OPLINE();
17704         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17705 
17706         if (1) {
17707                 MAKE_REAL_ZVAL_PTR(property);
17708         }
17709         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17710         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17711                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17712         }
17713 
17714         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
17715         if (1) {
17716                 zval_ptr_dtor(&property);
17717         } else {
17718                 zval_dtor(free_op2.var);
17719         }
17720         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17721                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17722         }
17723         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17724 
17725         /* We are going to assign the result by reference */
17726         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
17727                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
17728 
17729                 Z_DELREF_PP(retval_ptr);
17730                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
17731                 Z_ADDREF_PP(retval_ptr);
17732                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
17733                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
17734         }
17735 
17736         CHECK_EXCEPTION();
17737         ZEND_VM_NEXT_OPCODE();
17738 }
17739 
17740 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17741 {
17742         USE_OPLINE
17743         zend_free_op free_op1, free_op2;
17744         zval *property;
17745         zval **container;
17746 
17747         SAVE_OPLINE();
17748         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17749         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17750 
17751         if (1) {
17752                 MAKE_REAL_ZVAL_PTR(property);
17753         }
17754         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17755                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17756         }
17757         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
17758         if (1) {
17759                 zval_ptr_dtor(&property);
17760         } else {
17761                 zval_dtor(free_op2.var);
17762         }
17763         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17764                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17765         }
17766         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17767         CHECK_EXCEPTION();
17768         ZEND_VM_NEXT_OPCODE();
17769 }
17770 
17771 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17772 {
17773         USE_OPLINE
17774         zend_free_op free_op1;
17775         zval *container;
17776         zend_free_op free_op2;
17777         zval *offset;
17778 
17779         SAVE_OPLINE();
17780         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17781         offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17782 
17783         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
17784             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
17785                 PZVAL_LOCK(&EG(uninitialized_zval));
17786                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17787                 zval_dtor(free_op2.var);
17788         } else {
17789                 zval *retval;
17790 
17791                 if (1) {
17792                         MAKE_REAL_ZVAL_PTR(offset);
17793                 }
17794 
17795                 /* here we are sure we are dealing with an object */
17796                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17797 
17798                 PZVAL_LOCK(retval);
17799                 EX_T(opline->result.var).var.ptr = retval;
17800 
17801                 if (1) {
17802                         zval_ptr_dtor(&offset);
17803                 } else {
17804                         zval_dtor(free_op2.var);
17805                 }
17806         }
17807 
17808         zval_ptr_dtor_nogc(&free_op1.var);
17809         CHECK_EXCEPTION();
17810         ZEND_VM_NEXT_OPCODE();
17811 }
17812 
17813 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17814 {
17815         USE_OPLINE
17816 
17817         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
17818                 /* Behave like FETCH_OBJ_W */
17819                 zend_free_op free_op1, free_op2;
17820                 zval *property;
17821                 zval **container;
17822 
17823                 SAVE_OPLINE();
17824                 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17825                 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17826 
17827                 if (1) {
17828                         MAKE_REAL_ZVAL_PTR(property);
17829                 }
17830                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17831                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17832                 }
17833                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
17834                 if (1) {
17835                         zval_ptr_dtor(&property);
17836                 } else {
17837                         zval_dtor(free_op2.var);
17838                 }
17839                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17840                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17841                 }
17842                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17843                 CHECK_EXCEPTION();
17844                 ZEND_VM_NEXT_OPCODE();
17845         } else {
17846                 return zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
17847         }
17848 }
17849 
17850 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17851 {
17852         USE_OPLINE
17853         zend_free_op free_op1, free_op2, free_res;
17854         zval **container;
17855         zval *property;
17856 
17857         SAVE_OPLINE();
17858         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17859         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17860 
17861         if (IS_VAR == IS_CV) {
17862                 if (container != &EG(uninitialized_zval_ptr)) {
17863                         SEPARATE_ZVAL_IF_NOT_REF(container);
17864                 }
17865         }
17866         if (1) {
17867                 MAKE_REAL_ZVAL_PTR(property);
17868         }
17869         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
17870                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
17871         }
17872         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
17873         if (1) {
17874                 zval_ptr_dtor(&property);
17875         } else {
17876                 zval_dtor(free_op2.var);
17877         }
17878         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
17879                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
17880         }
17881         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17882 
17883         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
17884         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
17885                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
17886         }
17887         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
17888         FREE_OP_VAR_PTR(free_res);
17889         CHECK_EXCEPTION();
17890         ZEND_VM_NEXT_OPCODE();
17891 }
17892 
17893 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17894 {
17895         USE_OPLINE
17896         zend_free_op free_op1, free_op2;
17897         zval **object_ptr;
17898         zval *property_name;
17899 
17900         SAVE_OPLINE();
17901         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17902         property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17903 
17904         if (1) {
17905                 MAKE_REAL_ZVAL_PTR(property_name);
17906         }
17907         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17908                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17909         }
17910         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17911         if (1) {
17912                 zval_ptr_dtor(&property_name);
17913         } else {
17914                 zval_dtor(free_op2.var);
17915         }
17916         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17917         /* assign_obj has two opcodes! */
17918         CHECK_EXCEPTION();
17919         ZEND_VM_INC_OPCODE();
17920         ZEND_VM_NEXT_OPCODE();
17921 }
17922 
17923 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17924 {
17925         USE_OPLINE
17926         zend_free_op free_op1;
17927         zval **object_ptr;
17928 
17929         SAVE_OPLINE();
17930         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
17931 
17932         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
17933                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
17934         }
17935         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
17936                 zend_free_op free_op2;
17937                 zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17938 
17939                 if (1) {
17940                         MAKE_REAL_ZVAL_PTR(property_name);
17941                 }
17942                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
17943                 if (1) {
17944                         zval_ptr_dtor(&property_name);
17945                 } else {
17946                         zval_dtor(free_op2.var);
17947                 }
17948         } else {
17949                 zend_free_op free_op2, free_op_data1, free_op_data2;
17950                 zval *value;
17951                 zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
17952                 zval **variable_ptr_ptr;
17953 
17954                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
17955                 zval_dtor(free_op2.var);
17956 
17957                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
17958                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
17959                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
17960                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
17961                                 if (RETURN_VALUE_USED(opline)) {
17962                                         zval *retval;
17963 
17964                                         ALLOC_ZVAL(retval);
17965                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
17966                                         INIT_PZVAL(retval);
17967                                         EX_T(opline->result.var).var.ptr = retval;
17968                                 }
17969                         } else if (RETURN_VALUE_USED(opline)) {
17970                                 PZVAL_LOCK(&EG(uninitialized_zval));
17971                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17972                         }
17973                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
17974                         if (IS_TMP_FREE(free_op_data1)) {
17975                                 zval_dtor(value);
17976                         }
17977                         if (RETURN_VALUE_USED(opline)) {
17978                                 PZVAL_LOCK(&EG(uninitialized_zval));
17979                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
17980                         }
17981                 } else {
17982                         if ((opline+1)->op1_type == IS_TMP_VAR) {
17983                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
17984                         } else if ((opline+1)->op1_type == IS_CONST) {
17985                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
17986                         } else {
17987                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
17988                         }
17989                         if (RETURN_VALUE_USED(opline)) {
17990                                 PZVAL_LOCK(value);
17991                                 EX_T(opline->result.var).var.ptr = value;
17992                         }
17993                 }
17994                 FREE_OP_VAR_PTR(free_op_data2);
17995                 FREE_OP_IF_VAR(free_op_data1);
17996         }
17997         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
17998         /* assign_dim has two opcodes! */
17999         CHECK_EXCEPTION();
18000         ZEND_VM_INC_OPCODE();
18001         ZEND_VM_NEXT_OPCODE();
18002 }
18003 
18004 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18005 {
18006         USE_OPLINE
18007         zend_free_op free_op1, free_op2;
18008         zval *value;
18009         zval **variable_ptr_ptr;
18010 
18011         SAVE_OPLINE();
18012         value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18013         variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18014 
18015         if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
18016                 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
18017                         if (RETURN_VALUE_USED(opline)) {
18018                                 zval *retval;
18019 
18020                                 ALLOC_ZVAL(retval);
18021                                 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
18022                                 INIT_PZVAL(retval);
18023                                 EX_T(opline->result.var).var.ptr = retval;
18024                         }
18025                 } else if (RETURN_VALUE_USED(opline)) {
18026                         PZVAL_LOCK(&EG(uninitialized_zval));
18027                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
18028                 }
18029         } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
18030                 if (1) {
18031                         zval_dtor(value);
18032                 }
18033                 if (RETURN_VALUE_USED(opline)) {
18034                         PZVAL_LOCK(&EG(uninitialized_zval));
18035                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
18036                 }
18037         } else {
18038                 if (IS_TMP_VAR == IS_TMP_VAR) {
18039                         value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18040                 } else if (IS_TMP_VAR == IS_CONST) {
18041                         value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18042                 } else {
18043                         value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
18044                 }
18045                 if (RETURN_VALUE_USED(opline)) {
18046                         PZVAL_LOCK(value);
18047                         EX_T(opline->result.var).var.ptr = value;
18048                 }
18049         }
18050 
18051         if (IS_VAR == IS_VAR && (free_op1.var != NULL)) {
18052                 zval_ptr_dtor_nogc(&value);
18053         }
18054 
18055         /* zend_assign_to_variable() always takes care of op2, never free it! */
18056 
18057         CHECK_EXCEPTION();
18058         ZEND_VM_NEXT_OPCODE();
18059 }
18060 
18061 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18062 {
18063         USE_OPLINE
18064         zval *function_name;
18065         char *function_name_strval;
18066         int function_name_strlen;
18067         zend_free_op free_op1, free_op2;
18068         call_slot *call = EX(call_slots) + opline->result.num;
18069 
18070         SAVE_OPLINE();
18071 
18072         function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18073 
18074         if (IS_TMP_VAR != IS_CONST &&
18075             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18076                 if (UNEXPECTED(EG(exception) != NULL)) {
18077                         HANDLE_EXCEPTION();
18078                 }
18079                 zend_error_noreturn(E_ERROR, "Method name must be a string");
18080         }
18081 
18082         function_name_strval = Z_STRVAL_P(function_name);
18083         function_name_strlen = Z_STRLEN_P(function_name);
18084 
18085         call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18086 
18087         if (EXPECTED(call->object != NULL) &&
18088             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
18089                 call->called_scope = Z_OBJCE_P(call->object);
18090 
18091                 if (IS_TMP_VAR != IS_CONST ||
18092                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
18093                     zval *object = call->object;
18094 
18095                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
18096                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
18097                         }
18098 
18099                         /* First, locate the function. */
18100                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
18101                         if (UNEXPECTED(call->fbc == NULL)) {
18102                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
18103                         }
18104                         if (IS_TMP_VAR == IS_CONST &&
18105                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
18106                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
18107                             EXPECTED(call->object == object)) {
18108                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
18109                         }
18110                 }
18111         } else {
18112                 if (UNEXPECTED(EG(exception) != NULL)) {
18113                         zval_dtor(free_op2.var);
18114                         HANDLE_EXCEPTION();
18115                 }
18116                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
18117         }
18118 
18119         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
18120                 call->object = NULL;
18121         } else {
18122                 if (!PZVAL_IS_REF(call->object)) {
18123                         Z_ADDREF_P(call->object); /* For $this pointer */
18124                 } else {
18125                         zval *this_ptr;
18126                         ALLOC_ZVAL(this_ptr);
18127                         INIT_PZVAL_COPY(this_ptr, call->object);
18128                         zval_copy_ctor(this_ptr);
18129                         call->object = this_ptr;
18130                 }
18131         }
18132 
18133         call->num_additional_args = 0;
18134         call->is_ctor_call = 0;
18135         EX(call) = call;
18136 
18137         zval_dtor(free_op2.var);
18138         zval_ptr_dtor_nogc(&free_op1.var);
18139 
18140         CHECK_EXCEPTION();
18141         ZEND_VM_NEXT_OPCODE();
18142 }
18143 
18144 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18145 {
18146         USE_OPLINE
18147         zval *function_name;
18148         zend_class_entry *ce;
18149         call_slot *call = EX(call_slots) + opline->result.num;
18150 
18151         SAVE_OPLINE();
18152 
18153         if (IS_VAR == IS_CONST) {
18154                 /* no function found. try a static method in class */
18155                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
18156                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
18157                 } else {
18158                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
18159                         if (UNEXPECTED(EG(exception) != NULL)) {
18160                                 HANDLE_EXCEPTION();
18161                         }
18162                         if (UNEXPECTED(ce == NULL)) {
18163                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
18164                         }
18165                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
18166                 }
18167                 call->called_scope = ce;
18168         } else {
18169                 ce = EX_T(opline->op1.var).class_entry;
18170 
18171                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
18172                         call->called_scope = EG(called_scope);
18173                 } else {
18174                         call->called_scope = ce;
18175                 }
18176         }
18177 
18178         if (IS_VAR == IS_CONST &&
18179             IS_TMP_VAR == IS_CONST &&
18180             CACHED_PTR(opline->op2.literal->cache_slot)) {
18181                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
18182         } else if (IS_VAR != IS_CONST &&
18183                    IS_TMP_VAR == IS_CONST &&
18184                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
18185                 /* do nothing */
18186         } else if (IS_TMP_VAR != IS_UNUSED) {
18187                 char *function_name_strval = NULL;
18188                 int function_name_strlen = 0;
18189                 zend_free_op free_op2;
18190 
18191                 if (IS_TMP_VAR == IS_CONST) {
18192                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
18193                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
18194                 } else {
18195                         function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18196 
18197                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18198                                 if (UNEXPECTED(EG(exception) != NULL)) {
18199                                         HANDLE_EXCEPTION();
18200                                 }
18201                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
18202                         } else {
18203                                 function_name_strval = Z_STRVAL_P(function_name);
18204                                 function_name_strlen = Z_STRLEN_P(function_name);
18205                         }
18206                 }
18207 
18208                 if (function_name_strval) {
18209                         if (ce->get_static_method) {
18210                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
18211                         } else {
18212                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
18213                         }
18214                         if (UNEXPECTED(call->fbc == NULL)) {
18215                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
18216                         }
18217                         if (IS_TMP_VAR == IS_CONST &&
18218                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
18219                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
18220                                 if (IS_VAR == IS_CONST) {
18221                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
18222                                 } else {
18223                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
18224                                 }
18225                         }
18226                 }
18227                 if (IS_TMP_VAR != IS_CONST) {
18228                         zval_dtor(free_op2.var);
18229                 }
18230         } else {
18231                 if (UNEXPECTED(ce->constructor == NULL)) {
18232                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
18233                 }
18234                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
18235                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
18236                 }
18237                 call->fbc = ce->constructor;
18238         }
18239 
18240         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
18241                 call->object = NULL;
18242         } else {
18243                 if (EG(This) &&
18244                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
18245                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
18246                     /* We are calling method of the other (incompatible) class,
18247                        but passing $this. This is done for compatibility with php-4. */
18248                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
18249                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
18250                         } else {
18251                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
18252                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
18253                         }
18254                 }
18255                 if ((call->object = EG(This))) {
18256                         Z_ADDREF_P(call->object);
18257                         call->called_scope = Z_OBJCE_P(call->object);
18258                 }
18259         }
18260 
18261         call->num_additional_args = 0;
18262         call->is_ctor_call = 0;
18263         EX(call) = call;
18264 
18265         CHECK_EXCEPTION();
18266         ZEND_VM_NEXT_OPCODE();
18267 }
18268 
18269 static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18270 {
18271         USE_OPLINE
18272         zend_free_op free_op1, free_op2;
18273 
18274         SAVE_OPLINE();
18275         is_equal_function(&EX_T(opline->result.var).tmp_var,
18276                                  _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18277                                  _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18278 
18279         zval_dtor(free_op2.var);
18280         CHECK_EXCEPTION();
18281         ZEND_VM_NEXT_OPCODE();
18282 }
18283 
18284 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18285 {
18286         USE_OPLINE
18287         zend_free_op free_op1;
18288         zval *expr_ptr;
18289 
18290         SAVE_OPLINE();
18291         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
18292                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18293 
18294                 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
18295                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
18296                 }
18297                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
18298                 expr_ptr = *expr_ptr_ptr;
18299                 Z_ADDREF_P(expr_ptr);
18300         } else {
18301                 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18302                 if (0) { /* temporary variable */
18303                         zval *new_expr;
18304 
18305                         ALLOC_ZVAL(new_expr);
18306                         INIT_PZVAL_COPY(new_expr, expr_ptr);
18307                         expr_ptr = new_expr;
18308                 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
18309                         zval *new_expr;
18310 
18311                         ALLOC_ZVAL(new_expr);
18312                         INIT_PZVAL_COPY(new_expr, expr_ptr);
18313                         expr_ptr = new_expr;
18314                         zendi_zval_copy_ctor(*expr_ptr);
18315                         zval_ptr_dtor_nogc(&free_op1.var);
18316                 } else if (IS_VAR == IS_CV) {
18317                         Z_ADDREF_P(expr_ptr);
18318                 }
18319         }
18320 
18321         if (IS_TMP_VAR != IS_UNUSED) {
18322                 zend_free_op free_op2;
18323                 zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18324                 ulong hval;
18325 
18326                 switch (Z_TYPE_P(offset)) {
18327                         case IS_DOUBLE:
18328                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
18329                                 goto num_index;
18330                         case IS_LONG:
18331                         case IS_BOOL:
18332                                 hval = Z_LVAL_P(offset);
18333 num_index:
18334                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
18335                                 break;
18336                         case IS_STRING:
18337                                 if (IS_TMP_VAR == IS_CONST) {
18338                                         hval = Z_HASH_P(offset);
18339                                 } else {
18340                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
18341                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
18342                                 }
18343                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
18344                                 break;
18345                         case IS_NULL:
18346                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
18347                                 break;
18348                         default:
18349                                 zend_error(E_WARNING, "Illegal offset type");
18350                                 zval_ptr_dtor(&expr_ptr);
18351                                 /* do nothing */
18352                                 break;
18353                 }
18354                 zval_dtor(free_op2.var);
18355         } else {
18356                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
18357         }
18358         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
18359                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18360         }
18361         CHECK_EXCEPTION();
18362         ZEND_VM_NEXT_OPCODE();
18363 }
18364 
18365 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18366 {
18367         USE_OPLINE
18368 
18369         array_init(&EX_T(opline->result.var).tmp_var);
18370         if (IS_VAR == IS_UNUSED) {
18371                 ZEND_VM_NEXT_OPCODE();
18372 #if 0 || IS_VAR != IS_UNUSED
18373         } else {
18374                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18375 #endif
18376         }
18377 }
18378 
18379 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18380 {
18381         USE_OPLINE
18382         zend_free_op free_op1, free_op2;
18383         zval **container;
18384         zval *offset;
18385         ulong hval;
18386 
18387         SAVE_OPLINE();
18388         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18389         if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
18390                 SEPARATE_ZVAL_IF_NOT_REF(container);
18391         }
18392         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18393 
18394         if (IS_VAR != IS_VAR || container) {
18395                 switch (Z_TYPE_PP(container)) {
18396                         case IS_ARRAY: {
18397                                 HashTable *ht = Z_ARRVAL_PP(container);
18398 
18399                                 switch (Z_TYPE_P(offset)) {
18400                                         case IS_DOUBLE:
18401                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
18402                                                 zend_hash_index_del(ht, hval);
18403                                                 break;
18404                                         case IS_RESOURCE:
18405                                         case IS_BOOL:
18406                                         case IS_LONG:
18407                                                 hval = Z_LVAL_P(offset);
18408                                                 zend_hash_index_del(ht, hval);
18409                                                 break;
18410                                         case IS_STRING:
18411                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
18412                                                         Z_ADDREF_P(offset);
18413                                                 }
18414                                                 if (IS_TMP_VAR == IS_CONST) {
18415                                                         hval = Z_HASH_P(offset);
18416                                                 } else {
18417                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
18418                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
18419                                                 }
18420                                                 if (ht == &EG(symbol_table)) {
18421                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
18422                                                 } else {
18423                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
18424                                                 }
18425                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
18426                                                         zval_ptr_dtor(&offset);
18427                                                 }
18428                                                 break;
18429 num_index_dim:
18430                                                 zend_hash_index_del(ht, hval);
18431                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
18432                                                         zval_ptr_dtor(&offset);
18433                                                 }
18434                                                 break;
18435                                         case IS_NULL:
18436                                                 zend_hash_del(ht, "", sizeof(""));
18437                                                 break;
18438                                         default:
18439                                                 zend_error(E_WARNING, "Illegal offset type in unset");
18440                                                 break;
18441                                 }
18442                                 zval_dtor(free_op2.var);
18443                                 break;
18444                         }
18445                         case IS_OBJECT:
18446                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
18447                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
18448                                 }
18449                                 if (1) {
18450                                         MAKE_REAL_ZVAL_PTR(offset);
18451                                 }
18452                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
18453                                 if (1) {
18454                                         zval_ptr_dtor(&offset);
18455                                 } else {
18456                                         zval_dtor(free_op2.var);
18457                                 }
18458                                 break;
18459                         case IS_STRING:
18460                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
18461                                 ZEND_VM_CONTINUE(); /* bailed out before */
18462                         default:
18463                                 zval_dtor(free_op2.var);
18464                                 break;
18465                 }
18466         } else {
18467                 zval_dtor(free_op2.var);
18468         }
18469         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18470 
18471         CHECK_EXCEPTION();
18472         ZEND_VM_NEXT_OPCODE();
18473 }
18474 
18475 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18476 {
18477         USE_OPLINE
18478         zend_free_op free_op1, free_op2;
18479         zval **container;
18480         zval *offset;
18481 
18482         SAVE_OPLINE();
18483         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18484         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18485 
18486         if (IS_VAR != IS_VAR || container) {
18487                 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
18488                         SEPARATE_ZVAL_IF_NOT_REF(container);
18489                 }
18490                 if (Z_TYPE_PP(container) == IS_OBJECT) {
18491                         if (1) {
18492                                 MAKE_REAL_ZVAL_PTR(offset);
18493                         }
18494                         if (Z_OBJ_HT_P(*container)->unset_property) {
18495                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
18496                         } else {
18497                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
18498                         }
18499                         if (1) {
18500                                 zval_ptr_dtor(&offset);
18501                         } else {
18502                                 zval_dtor(free_op2.var);
18503                         }
18504                 } else {
18505                         zval_dtor(free_op2.var);
18506                 }
18507         } else {
18508                 zval_dtor(free_op2.var);
18509         }
18510         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18511 
18512         CHECK_EXCEPTION();
18513         ZEND_VM_NEXT_OPCODE();
18514 }
18515 
18516 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
18517 {
18518         USE_OPLINE
18519         zend_free_op free_op1, free_op2;
18520         zval *container;
18521         zval **value = NULL;
18522         int result = 0;
18523         ulong hval;
18524         zval *offset;
18525 
18526         SAVE_OPLINE();
18527         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18528         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18529 
18530         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
18531                 HashTable *ht;
18532                 int isset = 0;
18533 
18534                 ht = Z_ARRVAL_P(container);
18535 
18536                 switch (Z_TYPE_P(offset)) {
18537                         case IS_DOUBLE:
18538                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
18539                                 goto num_index_prop;
18540                         case IS_RESOURCE:
18541                         case IS_BOOL:
18542                         case IS_LONG:
18543                                 hval = Z_LVAL_P(offset);
18544 num_index_prop:
18545                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
18546                                         isset = 1;
18547                                 }
18548                                 break;
18549                         case IS_STRING:
18550                                 if (IS_TMP_VAR == IS_CONST) {
18551                                         hval = Z_HASH_P(offset);
18552                                 } else {
18553                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
18554                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
18555                                 }
18556                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
18557                                         isset = 1;
18558                                 }
18559                                 break;
18560                         case IS_NULL:
18561                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
18562                                         isset = 1;
18563                                 }
18564                                 break;
18565                         default:
18566                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
18567                                 break;
18568                 }
18569 
18570                 if (opline->extended_value & ZEND_ISSET) {
18571                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
18572                                 result = 0;
18573                         } else {
18574                                 result = isset;
18575                         }
18576                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
18577                         if (!isset || !i_zend_is_true(*value)) {
18578                                 result = 0;
18579                         } else {
18580                                 result = 1;
18581                         }
18582                 }
18583                 zval_dtor(free_op2.var);
18584         } else if (Z_TYPE_P(container) == IS_OBJECT) {
18585                 if (1) {
18586                         MAKE_REAL_ZVAL_PTR(offset);
18587                 }
18588                 if (prop_dim) {
18589                         if (Z_OBJ_HT_P(container)->has_property) {
18590                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
18591                         } else {
18592                                 zend_error(E_NOTICE, "Trying to check property of non-object");
18593                                 result = 0;
18594                         }
18595                 } else {
18596                         if (Z_OBJ_HT_P(container)->has_dimension) {
18597                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
18598                         } else {
18599                                 zend_error(E_NOTICE, "Trying to check element of non-array");
18600                                 result = 0;
18601                         }
18602                 }
18603                 if (1) {
18604                         zval_ptr_dtor(&offset);
18605                 } else {
18606                         zval_dtor(free_op2.var);
18607                 }
18608         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
18609                 zval tmp;
18610 
18611                 if (Z_TYPE_P(offset) != IS_LONG) {
18612                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
18613                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
18614                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
18615                                 ZVAL_COPY_VALUE(&tmp, offset);
18616                                 zval_copy_ctor(&tmp);
18617                                 convert_to_long(&tmp);
18618                                 offset = &tmp;
18619                         } else {
18620                                 /* can not be converted to proper offset, return "not set" */
18621                                 result = 0;
18622                         }
18623                 }
18624                 if (Z_TYPE_P(offset) == IS_LONG) {
18625                         if (opline->extended_value & ZEND_ISSET) {
18626                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
18627                                         result = 1;
18628                                 }
18629                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
18630                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
18631                                         result = 1;
18632                                 }
18633                         }
18634                 }
18635                 zval_dtor(free_op2.var);
18636         } else {
18637                 zval_dtor(free_op2.var);
18638         }
18639 
18640         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
18641         if (opline->extended_value & ZEND_ISSET) {
18642                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
18643         } else {
18644                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
18645         }
18646 
18647         zval_ptr_dtor_nogc(&free_op1.var);
18648 
18649         CHECK_EXCEPTION();
18650         ZEND_VM_NEXT_OPCODE();
18651 }
18652 
18653 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18654 {
18655         return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18656 }
18657 
18658 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18659 {
18660         return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18661 }
18662 
18663 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18664 {
18665         USE_OPLINE
18666 
18667         /* The generator object is stored in return_value_ptr_ptr */
18668         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
18669 
18670         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
18671                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
18672         }
18673 
18674         /* Destroy the previously yielded value */
18675         if (generator->value) {
18676                 zval_ptr_dtor(&generator->value);
18677         }
18678 
18679         /* Destroy the previously yielded key */
18680         if (generator->key) {
18681                 zval_ptr_dtor(&generator->key);
18682         }
18683 
18684         /* Set the new yielded value */
18685         if (IS_VAR != IS_UNUSED) {
18686                 zend_free_op free_op1;
18687 
18688                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
18689                         /* Constants and temporary variables aren't yieldable by reference,
18690                          * but we still allow them with a notice. */
18691                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
18692                                 zval *value, *copy;
18693 
18694                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
18695 
18696                                 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18697                                 ALLOC_ZVAL(copy);
18698                                 INIT_PZVAL_COPY(copy, value);
18699 
18700                                 /* Temporary variables don't need ctor copying */
18701                                 if (!0) {
18702                                         zval_copy_ctor(copy);
18703                                 }
18704 
18705                                 generator->value = copy;
18706                         } else {
18707                                 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18708 
18709                                 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
18710                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
18711                                 }
18712 
18713                                 /* If a function call result is yielded and the function did
18714                                  * not return by reference we throw a notice. */
18715                                 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
18716                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
18717                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
18718                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
18719                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
18720 
18721                                         Z_ADDREF_PP(value_ptr);
18722                                         generator->value = *value_ptr;
18723                                 } else {
18724                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
18725                                         Z_ADDREF_PP(value_ptr);
18726                                         generator->value = *value_ptr;
18727                                 }
18728 
18729                                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
18730                         }
18731                 } else {
18732                         zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
18733 
18734                         /* Consts, temporary variables and references need copying */
18735                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
18736                                 || PZVAL_IS_REF(value)
18737                         ) {
18738                                 zval *copy;
18739 
18740                                 ALLOC_ZVAL(copy);
18741                                 INIT_PZVAL_COPY(copy, value);
18742 
18743                                 /* Temporary variables don't need ctor copying */
18744                                 if (!0) {
18745                                         zval_copy_ctor(copy);
18746                                 }
18747 
18748                                 generator->value = copy;
18749                                 zval_ptr_dtor_nogc(&free_op1.var);
18750                         } else {
18751                                 if (IS_VAR == IS_CV) {
18752                                         Z_ADDREF_P(value);
18753                                 }
18754                                 generator->value = value;
18755                         }
18756                 }
18757         } else {
18758                 /* If no value was specified yield null */
18759                 Z_ADDREF(EG(uninitialized_zval));
18760                 generator->value = &EG(uninitialized_zval);
18761         }
18762 
18763         /* Set the new yielded key */
18764         if (IS_TMP_VAR != IS_UNUSED) {
18765                 zend_free_op free_op2;
18766                 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
18767 
18768                 /* Consts, temporary variables and references need copying */
18769                 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
18770                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
18771                 ) {
18772                         zval *copy;
18773 
18774                         ALLOC_ZVAL(copy);
18775                         INIT_PZVAL_COPY(copy, key);
18776 
18777                         /* Temporary variables don't need ctor copying */
18778                         if (!1) {
18779                                 zval_copy_ctor(copy);
18780                         }
18781 
18782                         generator->key = copy;
18783                 } else {
18784                         Z_ADDREF_P(key);
18785                         generator->key = key;
18786                 }
18787 
18788                 if (Z_TYPE_P(generator->key) == IS_LONG
18789                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
18790                 ) {
18791                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
18792                 }
18793 
18794         } else {
18795                 /* If no key was specified we use auto-increment keys */
18796                 generator->largest_used_integer_key++;
18797 
18798                 ALLOC_INIT_ZVAL(generator->key);
18799                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
18800         }
18801 
18802         if (RETURN_VALUE_USED(opline)) {
18803                 /* If the return value of yield is used set the send
18804                  * target and initialize it to NULL */
18805                 generator->send_target = &EX_T(opline->result.var).var.ptr;
18806                 Z_ADDREF(EG(uninitialized_zval));
18807                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
18808         } else {
18809                 generator->send_target = NULL;
18810         }
18811 
18812         /* We increment to the next op, so we are at the correct position when the
18813          * generator is resumed. */
18814         ZEND_VM_INC_OPCODE();
18815 
18816         /* The GOTO VM uses a local opline variable. We need to set the opline
18817          * variable in execute_data so we don't resume at an old position. */
18818         SAVE_OPLINE();
18819 
18820         ZEND_VM_RETURN();
18821 }
18822 
18823 static int ZEND_FASTCALL  ZEND_POW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18824 {
18825         USE_OPLINE
18826         zend_free_op free_op1, free_op2;
18827 
18828         SAVE_OPLINE();
18829         pow_function(&EX_T(opline->result.var).tmp_var,
18830                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18831                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18832         zval_ptr_dtor_nogc(&free_op1.var);
18833         zval_dtor(free_op2.var);
18834         CHECK_EXCEPTION();
18835         ZEND_VM_NEXT_OPCODE();
18836 }
18837 
18838 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18839 {
18840         return zend_binary_assign_op_helper_SPEC_VAR_TMP(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
18841 }
18842 
18843 static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18844 {
18845         USE_OPLINE
18846         zend_free_op free_op1, free_op2;
18847 
18848         SAVE_OPLINE();
18849         fast_add_function(&EX_T(opline->result.var).tmp_var,
18850                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18851                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18852         zval_ptr_dtor_nogc(&free_op1.var);
18853         zval_ptr_dtor_nogc(&free_op2.var);
18854         CHECK_EXCEPTION();
18855         ZEND_VM_NEXT_OPCODE();
18856 }
18857 
18858 static int ZEND_FASTCALL  ZEND_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18859 {
18860         USE_OPLINE
18861         zend_free_op free_op1, free_op2;
18862 
18863         SAVE_OPLINE();
18864         fast_sub_function(&EX_T(opline->result.var).tmp_var,
18865                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18866                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18867         zval_ptr_dtor_nogc(&free_op1.var);
18868         zval_ptr_dtor_nogc(&free_op2.var);
18869         CHECK_EXCEPTION();
18870         ZEND_VM_NEXT_OPCODE();
18871 }
18872 
18873 static int ZEND_FASTCALL  ZEND_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18874 {
18875         USE_OPLINE
18876         zend_free_op free_op1, free_op2;
18877 
18878         SAVE_OPLINE();
18879         fast_mul_function(&EX_T(opline->result.var).tmp_var,
18880                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18881                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18882         zval_ptr_dtor_nogc(&free_op1.var);
18883         zval_ptr_dtor_nogc(&free_op2.var);
18884         CHECK_EXCEPTION();
18885         ZEND_VM_NEXT_OPCODE();
18886 }
18887 
18888 static int ZEND_FASTCALL  ZEND_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18889 {
18890         USE_OPLINE
18891         zend_free_op free_op1, free_op2;
18892 
18893         SAVE_OPLINE();
18894         fast_div_function(&EX_T(opline->result.var).tmp_var,
18895                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18896                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18897         zval_ptr_dtor_nogc(&free_op1.var);
18898         zval_ptr_dtor_nogc(&free_op2.var);
18899         CHECK_EXCEPTION();
18900         ZEND_VM_NEXT_OPCODE();
18901 }
18902 
18903 static int ZEND_FASTCALL  ZEND_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18904 {
18905         USE_OPLINE
18906         zend_free_op free_op1, free_op2;
18907 
18908         SAVE_OPLINE();
18909         fast_mod_function(&EX_T(opline->result.var).tmp_var,
18910                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18911                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18912         zval_ptr_dtor_nogc(&free_op1.var);
18913         zval_ptr_dtor_nogc(&free_op2.var);
18914         CHECK_EXCEPTION();
18915         ZEND_VM_NEXT_OPCODE();
18916 }
18917 
18918 static int ZEND_FASTCALL  ZEND_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18919 {
18920         USE_OPLINE
18921         zend_free_op free_op1, free_op2;
18922 
18923         SAVE_OPLINE();
18924         shift_left_function(&EX_T(opline->result.var).tmp_var,
18925                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18926                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18927         zval_ptr_dtor_nogc(&free_op1.var);
18928         zval_ptr_dtor_nogc(&free_op2.var);
18929         CHECK_EXCEPTION();
18930         ZEND_VM_NEXT_OPCODE();
18931 }
18932 
18933 static int ZEND_FASTCALL  ZEND_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18934 {
18935         USE_OPLINE
18936         zend_free_op free_op1, free_op2;
18937 
18938         SAVE_OPLINE();
18939         shift_right_function(&EX_T(opline->result.var).tmp_var,
18940                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18941                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18942         zval_ptr_dtor_nogc(&free_op1.var);
18943         zval_ptr_dtor_nogc(&free_op2.var);
18944         CHECK_EXCEPTION();
18945         ZEND_VM_NEXT_OPCODE();
18946 }
18947 
18948 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18949 {
18950         USE_OPLINE
18951         zend_free_op free_op1, free_op2;
18952 
18953         SAVE_OPLINE();
18954         concat_function(&EX_T(opline->result.var).tmp_var,
18955                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18956                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18957         zval_ptr_dtor_nogc(&free_op1.var);
18958         zval_ptr_dtor_nogc(&free_op2.var);
18959         CHECK_EXCEPTION();
18960         ZEND_VM_NEXT_OPCODE();
18961 }
18962 
18963 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18964 {
18965         USE_OPLINE
18966         zend_free_op free_op1, free_op2;
18967 
18968         SAVE_OPLINE();
18969         is_identical_function(&EX_T(opline->result.var).tmp_var,
18970                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18971                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18972         zval_ptr_dtor_nogc(&free_op1.var);
18973         zval_ptr_dtor_nogc(&free_op2.var);
18974         CHECK_EXCEPTION();
18975         ZEND_VM_NEXT_OPCODE();
18976 }
18977 
18978 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18979 {
18980         USE_OPLINE
18981         zend_free_op free_op1, free_op2;
18982         zval *result = &EX_T(opline->result.var).tmp_var;
18983 
18984         SAVE_OPLINE();
18985         is_identical_function(result,
18986                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
18987                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
18988         Z_LVAL_P(result) = !Z_LVAL_P(result);
18989         zval_ptr_dtor_nogc(&free_op1.var);
18990         zval_ptr_dtor_nogc(&free_op2.var);
18991         CHECK_EXCEPTION();
18992         ZEND_VM_NEXT_OPCODE();
18993 }
18994 
18995 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18996 {
18997         USE_OPLINE
18998         zend_free_op free_op1, free_op2;
18999         zval *result = &EX_T(opline->result.var).tmp_var;
19000 
19001         SAVE_OPLINE();
19002         ZVAL_BOOL(result, fast_equal_function(result,
19003                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19004                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
19005         zval_ptr_dtor_nogc(&free_op1.var);
19006         zval_ptr_dtor_nogc(&free_op2.var);
19007         CHECK_EXCEPTION();
19008         ZEND_VM_NEXT_OPCODE();
19009 }
19010 
19011 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19012 {
19013         USE_OPLINE
19014         zend_free_op free_op1, free_op2;
19015         zval *result = &EX_T(opline->result.var).tmp_var;
19016 
19017         SAVE_OPLINE();
19018         ZVAL_BOOL(result, fast_not_equal_function(result,
19019                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19020                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
19021         zval_ptr_dtor_nogc(&free_op1.var);
19022         zval_ptr_dtor_nogc(&free_op2.var);
19023         CHECK_EXCEPTION();
19024         ZEND_VM_NEXT_OPCODE();
19025 }
19026 
19027 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19028 {
19029         USE_OPLINE
19030         zend_free_op free_op1, free_op2;
19031         zval *result = &EX_T(opline->result.var).tmp_var;
19032 
19033         SAVE_OPLINE();
19034         ZVAL_BOOL(result, fast_is_smaller_function(result,
19035                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19036                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
19037         zval_ptr_dtor_nogc(&free_op1.var);
19038         zval_ptr_dtor_nogc(&free_op2.var);
19039         CHECK_EXCEPTION();
19040         ZEND_VM_NEXT_OPCODE();
19041 }
19042 
19043 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19044 {
19045         USE_OPLINE
19046         zend_free_op free_op1, free_op2;
19047         zval *result = &EX_T(opline->result.var).tmp_var;
19048 
19049         SAVE_OPLINE();
19050         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
19051                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19052                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
19053         zval_ptr_dtor_nogc(&free_op1.var);
19054         zval_ptr_dtor_nogc(&free_op2.var);
19055         CHECK_EXCEPTION();
19056         ZEND_VM_NEXT_OPCODE();
19057 }
19058 
19059 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19060 {
19061         USE_OPLINE
19062         zend_free_op free_op1, free_op2;
19063 
19064         SAVE_OPLINE();
19065         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
19066                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19067                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19068         zval_ptr_dtor_nogc(&free_op1.var);
19069         zval_ptr_dtor_nogc(&free_op2.var);
19070         CHECK_EXCEPTION();
19071         ZEND_VM_NEXT_OPCODE();
19072 }
19073 
19074 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19075 {
19076         USE_OPLINE
19077         zend_free_op free_op1, free_op2;
19078 
19079         SAVE_OPLINE();
19080         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
19081                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19082                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19083         zval_ptr_dtor_nogc(&free_op1.var);
19084         zval_ptr_dtor_nogc(&free_op2.var);
19085         CHECK_EXCEPTION();
19086         ZEND_VM_NEXT_OPCODE();
19087 }
19088 
19089 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19090 {
19091         USE_OPLINE
19092         zend_free_op free_op1, free_op2;
19093 
19094         SAVE_OPLINE();
19095         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
19096                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19097                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19098         zval_ptr_dtor_nogc(&free_op1.var);
19099         zval_ptr_dtor_nogc(&free_op2.var);
19100         CHECK_EXCEPTION();
19101         ZEND_VM_NEXT_OPCODE();
19102 }
19103 
19104 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19105 {
19106         USE_OPLINE
19107         zend_free_op free_op1, free_op2;
19108 
19109         SAVE_OPLINE();
19110         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
19111                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
19112                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
19113         zval_ptr_dtor_nogc(&free_op1.var);
19114         zval_ptr_dtor_nogc(&free_op2.var);
19115         CHECK_EXCEPTION();
19116         ZEND_VM_NEXT_OPCODE();
19117 }
19118 
19119 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
19120 {
19121         USE_OPLINE
19122         zend_free_op free_op1, free_op2, free_op_data1;
19123         zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19124         zval *object;
19125         zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19126         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
19127         int have_get_ptr = 0;
19128 
19129         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
19130                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
19131         }
19132 
19133         make_real_object(object_ptr TSRMLS_CC);
19134         object = *object_ptr;
19135 
19136         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
19137                 zend_error(E_WARNING, "Attempt to assign property of non-object");
19138                 zval_ptr_dtor_nogc(&free_op2.var);
19139                 FREE_OP(free_op_data1);
19140 
19141                 if (RETURN_VALUE_USED(opline)) {
19142                         PZVAL_LOCK(&EG(uninitialized_zval));
19143                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
19144                 }
19145         } else {
19146                 /* here we are sure we are dealing with an object */
19147                 if (0) {
19148                         MAKE_REAL_ZVAL_PTR(property);
19149                 }
19150 
19151                 /* here property is a string */
19152                 if (opline->extended_value == ZEND_ASSIGN_OBJ
19153                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19154                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19155                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
19156                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
19157 
19158                                 have_get_ptr = 1;
19159                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
19160                                 if (RETURN_VALUE_USED(opline)) {
19161                                         PZVAL_LOCK(*zptr);
19162                                         EX_T(opline->result.var).var.ptr = *zptr;
19163                                 }
19164                         }
19165                 }
19166 
19167                 if (!have_get_ptr) {
19168                         zval *z = NULL;
19169 
19170                         Z_ADDREF_P(object);
19171                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
19172                                 if (Z_OBJ_HT_P(object)->read_property) {
19173                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19174                                 }
19175                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
19176                                 if (Z_OBJ_HT_P(object)->read_dimension) {
19177                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
19178                                 }
19179                         }
19180                         if (z) {
19181                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
19182                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19183 
19184                                         if (Z_REFCOUNT_P(z) == 0) {
19185                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
19186                                                 zval_dtor(z);
19187                                                 FREE_ZVAL(z);
19188                                         }
19189                                         z = value;
19190                                 }
19191                                 Z_ADDREF_P(z);
19192                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
19193                                 binary_op(z, z, value TSRMLS_CC);
19194                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
19195                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19196                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
19197                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
19198                                 }
19199                                 if (RETURN_VALUE_USED(opline)) {
19200                                         PZVAL_LOCK(z);
19201                                         EX_T(opline->result.var).var.ptr = z;
19202                                 }
19203                                 zval_ptr_dtor(&z);
19204                         } else {
19205                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
19206                                 if (RETURN_VALUE_USED(opline)) {
19207                                         PZVAL_LOCK(&EG(uninitialized_zval));
19208                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
19209                                 }
19210                         }
19211                         zval_ptr_dtor(&object);
19212                 }
19213 
19214                 if (0) {
19215                         zval_ptr_dtor(&property);
19216                 } else {
19217                         zval_ptr_dtor_nogc(&free_op2.var);
19218                 }
19219                 FREE_OP(free_op_data1);
19220         }
19221 
19222         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19223         /* assign_obj has two opcodes! */
19224         CHECK_EXCEPTION();
19225         ZEND_VM_INC_OPCODE();
19226         ZEND_VM_NEXT_OPCODE();
19227 }
19228 
19229 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
19230 {
19231         USE_OPLINE
19232         zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
19233         zval **var_ptr;
19234         zval *value;
19235 
19236         SAVE_OPLINE();
19237         switch (opline->extended_value) {
19238                 case ZEND_ASSIGN_OBJ:
19239                         return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19240                         break;
19241                 case ZEND_ASSIGN_DIM: {
19242                                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19243 
19244                                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19245                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19246                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
19247                                         if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
19248                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
19249                                         }
19250                                         return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19251                                 } else {
19252                                         zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19253 
19254                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
19255                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
19256                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
19257                                 }
19258                         }
19259                         break;
19260                 default:
19261                         value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19262                         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19263                         /* do nothing */
19264                         break;
19265         }
19266 
19267         if (UNEXPECTED(var_ptr == NULL)) {
19268                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
19269         }
19270 
19271         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
19272                 if (RETURN_VALUE_USED(opline)) {
19273                         PZVAL_LOCK(&EG(uninitialized_zval));
19274                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
19275                 }
19276                 zval_ptr_dtor_nogc(&free_op2.var);
19277                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19278                 CHECK_EXCEPTION();
19279                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
19280                         ZEND_VM_INC_OPCODE();
19281                 }
19282                 ZEND_VM_NEXT_OPCODE();
19283         }
19284 
19285         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
19286 
19287         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
19288            && Z_OBJ_HANDLER_PP(var_ptr, get)
19289            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
19290                 /* proxy object */
19291                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
19292                 Z_ADDREF_P(objval);
19293                 binary_op(objval, objval, value TSRMLS_CC);
19294                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
19295                 zval_ptr_dtor(&objval);
19296         } else {
19297                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
19298         }
19299 
19300         if (RETURN_VALUE_USED(opline)) {
19301                 PZVAL_LOCK(*var_ptr);
19302                 EX_T(opline->result.var).var.ptr = *var_ptr;
19303         }
19304         zval_ptr_dtor_nogc(&free_op2.var);
19305 
19306         if (opline->extended_value == ZEND_ASSIGN_DIM) {
19307                 FREE_OP(free_op_data1);
19308                 FREE_OP_VAR_PTR(free_op_data2);
19309                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19310                 CHECK_EXCEPTION();
19311                 ZEND_VM_INC_OPCODE();
19312         } else {
19313                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19314                 CHECK_EXCEPTION();
19315         }
19316         ZEND_VM_NEXT_OPCODE();
19317 }
19318 
19319 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19320 {
19321         return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19322 }
19323 
19324 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19325 {
19326         return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19327 }
19328 
19329 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19330 {
19331         return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19332 }
19333 
19334 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19335 {
19336         return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19337 }
19338 
19339 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19340 {
19341         return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19342 }
19343 
19344 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19345 {
19346         return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19347 }
19348 
19349 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19350 {
19351         return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19352 }
19353 
19354 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19355 {
19356         return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19357 }
19358 
19359 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19360 {
19361         return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19362 }
19363 
19364 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19365 {
19366         return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19367 }
19368 
19369 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19370 {
19371         return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19372 }
19373 
19374 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
19375 {
19376         USE_OPLINE
19377         zend_free_op free_op1, free_op2;
19378         zval **object_ptr;
19379         zval *object;
19380         zval *property;
19381         zval **retval;
19382         int have_get_ptr = 0;
19383 
19384         SAVE_OPLINE();
19385         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19386         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19387         retval = &EX_T(opline->result.var).var.ptr;
19388 
19389         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
19390                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
19391         }
19392 
19393         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
19394         object = *object_ptr;
19395 
19396         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
19397                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19398                 zval_ptr_dtor_nogc(&free_op2.var);
19399                 if (RETURN_VALUE_USED(opline)) {
19400                         PZVAL_LOCK(&EG(uninitialized_zval));
19401                         *retval = &EG(uninitialized_zval);
19402                 }
19403                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19404                 CHECK_EXCEPTION();
19405                 ZEND_VM_NEXT_OPCODE();
19406         }
19407 
19408         /* here we are sure we are dealing with an object */
19409 
19410         if (0) {
19411                 MAKE_REAL_ZVAL_PTR(property);
19412         }
19413 
19414         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19415                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19416                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
19417                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
19418 
19419                         have_get_ptr = 1;
19420                         incdec_op(*zptr);
19421                         if (RETURN_VALUE_USED(opline)) {
19422                                 *retval = *zptr;
19423                                 PZVAL_LOCK(*retval);
19424                         }
19425                 }
19426         }
19427 
19428         if (!have_get_ptr) {
19429                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
19430                         zval *z;
19431 
19432                         Z_ADDREF_P(object);
19433                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19434 
19435                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
19436                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19437 
19438                                 if (Z_REFCOUNT_P(z) == 0) {
19439                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
19440                                         zval_dtor(z);
19441                                         FREE_ZVAL(z);
19442                                 }
19443                                 z = value;
19444                         }
19445                         Z_ADDREF_P(z);
19446                         SEPARATE_ZVAL_IF_NOT_REF(&z);
19447                         incdec_op(z);
19448                         *retval = z;
19449                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19450                         zval_ptr_dtor(&object);
19451                         SELECTIVE_PZVAL_LOCK(*retval, opline);
19452                         zval_ptr_dtor(&z);
19453                 } else {
19454                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19455                         if (RETURN_VALUE_USED(opline)) {
19456                                 PZVAL_LOCK(&EG(uninitialized_zval));
19457                                 *retval = &EG(uninitialized_zval);
19458                         }
19459                 }
19460         }
19461 
19462         if (0) {
19463                 zval_ptr_dtor(&property);
19464         } else {
19465                 zval_ptr_dtor_nogc(&free_op2.var);
19466         }
19467         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19468         CHECK_EXCEPTION();
19469         ZEND_VM_NEXT_OPCODE();
19470 }
19471 
19472 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19473 {
19474         return zend_pre_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19475 }
19476 
19477 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19478 {
19479         return zend_pre_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19480 }
19481 
19482 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
19483 {
19484         USE_OPLINE
19485         zend_free_op free_op1, free_op2;
19486         zval **object_ptr;
19487         zval *object;
19488         zval *property;
19489         zval *retval;
19490         int have_get_ptr = 0;
19491 
19492         SAVE_OPLINE();
19493         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19494         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19495         retval = &EX_T(opline->result.var).tmp_var;
19496 
19497         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
19498                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
19499         }
19500 
19501         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
19502         object = *object_ptr;
19503 
19504         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
19505                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19506                 zval_ptr_dtor_nogc(&free_op2.var);
19507                 ZVAL_NULL(retval);
19508                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19509                 CHECK_EXCEPTION();
19510                 ZEND_VM_NEXT_OPCODE();
19511         }
19512 
19513         /* here we are sure we are dealing with an object */
19514 
19515         if (0) {
19516                 MAKE_REAL_ZVAL_PTR(property);
19517         }
19518 
19519         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
19520                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19521                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
19522                         have_get_ptr = 1;
19523                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
19524 
19525                         ZVAL_COPY_VALUE(retval, *zptr);
19526                         zendi_zval_copy_ctor(*retval);
19527 
19528                         incdec_op(*zptr);
19529 
19530                 }
19531         }
19532 
19533         if (!have_get_ptr) {
19534                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
19535                         zval *z, *z_copy;
19536 
19537                         Z_ADDREF_P(object);
19538                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19539                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
19540                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
19541 
19542                                 if (Z_REFCOUNT_P(z) == 0) {
19543                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
19544                                         zval_dtor(z);
19545                                         FREE_ZVAL(z);
19546                                 }
19547                                 z = value;
19548                         }
19549                         ZVAL_COPY_VALUE(retval, z);
19550                         zendi_zval_copy_ctor(*retval);
19551                         ALLOC_ZVAL(z_copy);
19552                         INIT_PZVAL_COPY(z_copy, z);
19553                         zendi_zval_copy_ctor(*z_copy);
19554                         incdec_op(z_copy);
19555                         Z_ADDREF_P(z);
19556                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19557                         zval_ptr_dtor(&object);
19558                         zval_ptr_dtor(&z_copy);
19559                         zval_ptr_dtor(&z);
19560                 } else {
19561                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
19562                         ZVAL_NULL(retval);
19563                 }
19564         }
19565 
19566         if (0) {
19567                 zval_ptr_dtor(&property);
19568         } else {
19569                 zval_ptr_dtor_nogc(&free_op2.var);
19570         }
19571         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19572         CHECK_EXCEPTION();
19573         ZEND_VM_NEXT_OPCODE();
19574 }
19575 
19576 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19577 {
19578         return zend_post_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19579 }
19580 
19581 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19582 {
19583         return zend_post_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19584 }
19585 
19586 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
19587 {
19588         USE_OPLINE
19589         zend_free_op free_op1;
19590         zval *varname;
19591         zval **retval;
19592         zval tmp_varname;
19593         HashTable *target_symbol_table;
19594         ulong hash_value;
19595 
19596         SAVE_OPLINE();
19597         varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19598 
19599         if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
19600                 ZVAL_COPY_VALUE(&tmp_varname, varname);
19601                 zval_copy_ctor(&tmp_varname);
19602                 Z_SET_REFCOUNT(tmp_varname, 1);
19603                 Z_UNSET_ISREF(tmp_varname);
19604                 convert_to_string(&tmp_varname);
19605                 varname = &tmp_varname;
19606         }
19607 
19608         if (IS_VAR != IS_UNUSED) {
19609                 zend_class_entry *ce;
19610 
19611                 if (IS_VAR == IS_CONST) {
19612                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
19613                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
19614                         } else {
19615                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
19616                                 if (UNEXPECTED(ce == NULL)) {
19617                                         if (IS_VAR != IS_CONST && varname == &tmp_varname) {
19618                                                 zval_dtor(&tmp_varname);
19619                                         }
19620                                         zval_ptr_dtor_nogc(&free_op1.var);
19621                                         CHECK_EXCEPTION();
19622                                         ZEND_VM_NEXT_OPCODE();
19623                                 }
19624                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
19625                         }
19626                 } else {
19627                         ce = EX_T(opline->op2.var).class_entry;
19628                 }
19629                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
19630                 zval_ptr_dtor_nogc(&free_op1.var);
19631         } else {
19632                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
19633 /*
19634                 if (!target_symbol_table) {
19635                         CHECK_EXCEPTION();
19636                         ZEND_VM_NEXT_OPCODE();
19637                 }
19638 */
19639                 if (IS_VAR == IS_CONST) {
19640                         hash_value = Z_HASH_P(varname);
19641                 } else {
19642                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
19643                 }
19644 
19645                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
19646                         switch (type) {
19647                                 case BP_VAR_R:
19648                                 case BP_VAR_UNSET:
19649                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
19650                                         /* break missing intentionally */
19651                                 case BP_VAR_IS:
19652                                         retval = &EG(uninitialized_zval_ptr);
19653                                         break;
19654                                 case BP_VAR_RW:
19655                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
19656                                         /* break missing intentionally */
19657                                 case BP_VAR_W:
19658                                         Z_ADDREF_P(&EG(uninitialized_zval));
19659                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
19660                                         break;
19661                                 EMPTY_SWITCH_DEFAULT_CASE()
19662                         }
19663                 }
19664                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
19665                         case ZEND_FETCH_GLOBAL:
19666                                 if (IS_VAR != IS_TMP_VAR) {
19667                                         zval_ptr_dtor_nogc(&free_op1.var);
19668                                 }
19669                                 break;
19670                         case ZEND_FETCH_LOCAL:
19671                                 zval_ptr_dtor_nogc(&free_op1.var);
19672                                 break;
19673                         case ZEND_FETCH_STATIC:
19674                                 zval_update_constant(retval, 1 TSRMLS_CC);
19675                                 break;
19676                         case ZEND_FETCH_GLOBAL_LOCK:
19677                                 if (IS_VAR == IS_VAR && !free_op1.var) {
19678                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
19679                                 }
19680                                 break;
19681                 }
19682         }
19683 
19684 
19685         if (IS_VAR != IS_CONST && varname == &tmp_varname) {
19686                 zval_dtor(&tmp_varname);
19687         }
19688         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
19689                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
19690         }
19691         PZVAL_LOCK(*retval);
19692         switch (type) {
19693                 case BP_VAR_R:
19694                 case BP_VAR_IS:
19695                         EX_T(opline->result.var).var.ptr = *retval;
19696                         break;
19697                 case BP_VAR_UNSET: {
19698                         zend_free_op free_res;
19699 
19700                         PZVAL_UNLOCK(*retval, &free_res);
19701                         if (retval != &EG(uninitialized_zval_ptr)) {
19702                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
19703                         }
19704                         PZVAL_LOCK(*retval);
19705                         FREE_OP_VAR_PTR(free_res);
19706                 }
19707                 /* break missing intentionally */
19708                 default:
19709                         EX_T(opline->result.var).var.ptr_ptr = retval;
19710                         break;
19711         }
19712         CHECK_EXCEPTION();
19713         ZEND_VM_NEXT_OPCODE();
19714 }
19715 
19716 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19717 {
19718         return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19719 }
19720 
19721 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19722 {
19723         return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19724 }
19725 
19726 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19727 {
19728         return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19729 }
19730 
19731 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19732 {
19733         USE_OPLINE
19734 
19735         return zend_fetch_var_address_helper_SPEC_VAR_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19736 }
19737 
19738 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19739 {
19740         return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19741 }
19742 
19743 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19744 {
19745         return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19746 }
19747 
19748 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19749 {
19750         USE_OPLINE
19751         zend_free_op free_op1, free_op2;
19752         zval *container;
19753 
19754         SAVE_OPLINE();
19755         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19756         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
19757         zval_ptr_dtor_nogc(&free_op2.var);
19758         if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
19759                 zval_ptr_dtor_nogc(&free_op1.var);
19760         }
19761         CHECK_EXCEPTION();
19762         ZEND_VM_NEXT_OPCODE();
19763 }
19764 
19765 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19766 {
19767         USE_OPLINE
19768         zend_free_op free_op1, free_op2;
19769         zval **container;
19770 
19771         SAVE_OPLINE();
19772         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19773 
19774         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19775                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19776         }
19777         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
19778         zval_ptr_dtor_nogc(&free_op2.var);
19779         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19780                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19781         }
19782         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19783 
19784         /* We are going to assign the result by reference */
19785         if (UNEXPECTED(opline->extended_value != 0)) {
19786                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
19787 
19788                 if (retval_ptr) {
19789                         Z_DELREF_PP(retval_ptr);
19790                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
19791                         Z_ADDREF_PP(retval_ptr);
19792                 }
19793         }
19794 
19795         CHECK_EXCEPTION();
19796         ZEND_VM_NEXT_OPCODE();
19797 }
19798 
19799 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19800 {
19801         USE_OPLINE
19802         zend_free_op free_op1, free_op2;
19803         zval **container;
19804 
19805         SAVE_OPLINE();
19806         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19807 
19808         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19809                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19810         }
19811         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
19812         zval_ptr_dtor_nogc(&free_op2.var);
19813         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19814                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19815         }
19816         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19817         CHECK_EXCEPTION();
19818         ZEND_VM_NEXT_OPCODE();
19819 }
19820 
19821 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19822 {
19823         USE_OPLINE
19824         zend_free_op free_op1, free_op2;
19825         zval *container;
19826 
19827         SAVE_OPLINE();
19828         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19829         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC);
19830         zval_ptr_dtor_nogc(&free_op2.var);
19831         zval_ptr_dtor_nogc(&free_op1.var);
19832         CHECK_EXCEPTION();
19833         ZEND_VM_NEXT_OPCODE();
19834 }
19835 
19836 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19837 {
19838         USE_OPLINE
19839         zend_free_op free_op1, free_op2;
19840 
19841         SAVE_OPLINE();
19842 
19843         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
19844                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19845                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19846                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19847                 }
19848                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
19849                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19850                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19851                 }
19852                 zval_ptr_dtor_nogc(&free_op2.var);
19853                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19854         } else {
19855                 zval *container;
19856 
19857                 if (IS_VAR == IS_UNUSED) {
19858                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
19859                 }
19860                 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19861                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
19862                 zval_ptr_dtor_nogc(&free_op2.var);
19863                 zval_ptr_dtor_nogc(&free_op1.var);
19864         }
19865         CHECK_EXCEPTION();
19866         ZEND_VM_NEXT_OPCODE();
19867 }
19868 
19869 static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19870 {
19871         USE_OPLINE
19872         zend_free_op free_op1, free_op2;
19873         zval **container;
19874 
19875         SAVE_OPLINE();
19876         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19877 
19878         if (IS_VAR == IS_CV) {
19879                 if (container != &EG(uninitialized_zval_ptr)) {
19880                         SEPARATE_ZVAL_IF_NOT_REF(container);
19881                 }
19882         }
19883         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19884                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
19885         }
19886         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC);
19887         zval_ptr_dtor_nogc(&free_op2.var);
19888         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19889                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19890         }
19891         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19892         if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
19893                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
19894                 ZEND_VM_NEXT_OPCODE();
19895         } else {
19896                 zend_free_op free_res;
19897                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
19898 
19899                 PZVAL_UNLOCK(*retval_ptr, &free_res);
19900                 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
19901                         SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
19902                 }
19903                 PZVAL_LOCK(*retval_ptr);
19904                 FREE_OP_VAR_PTR(free_res);
19905                 CHECK_EXCEPTION();
19906                 ZEND_VM_NEXT_OPCODE();
19907         }
19908 }
19909 
19910 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS)
19911 {
19912         USE_OPLINE
19913         zend_free_op free_op1;
19914         zval *container;
19915         zend_free_op free_op2;
19916         zval *offset;
19917 
19918         SAVE_OPLINE();
19919         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19920         offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19921 
19922         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
19923             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
19924                 zend_error(E_NOTICE, "Trying to get property of non-object");
19925                 PZVAL_LOCK(&EG(uninitialized_zval));
19926                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
19927                 zval_ptr_dtor_nogc(&free_op2.var);
19928         } else {
19929                 zval *retval;
19930 
19931                 if (0) {
19932                         MAKE_REAL_ZVAL_PTR(offset);
19933                 }
19934 
19935                 /* here we are sure we are dealing with an object */
19936                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
19937 
19938                 PZVAL_LOCK(retval);
19939                 EX_T(opline->result.var).var.ptr = retval;
19940 
19941                 if (0) {
19942                         zval_ptr_dtor(&offset);
19943                 } else {
19944                         zval_ptr_dtor_nogc(&free_op2.var);
19945                 }
19946         }
19947 
19948         zval_ptr_dtor_nogc(&free_op1.var);
19949         CHECK_EXCEPTION();
19950         ZEND_VM_NEXT_OPCODE();
19951 }
19952 
19953 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19954 {
19955         return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
19956 }
19957 
19958 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19959 {
19960         USE_OPLINE
19961         zend_free_op free_op1, free_op2;
19962         zval *property;
19963         zval **container;
19964 
19965         SAVE_OPLINE();
19966         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
19967 
19968         if (0) {
19969                 MAKE_REAL_ZVAL_PTR(property);
19970         }
19971         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
19972         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
19973                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
19974         }
19975 
19976         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
19977         if (0) {
19978                 zval_ptr_dtor(&property);
19979         } else {
19980                 zval_ptr_dtor_nogc(&free_op2.var);
19981         }
19982         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
19983                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
19984         }
19985         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
19986 
19987         /* We are going to assign the result by reference */
19988         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
19989                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
19990 
19991                 Z_DELREF_PP(retval_ptr);
19992                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
19993                 Z_ADDREF_PP(retval_ptr);
19994                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
19995                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
19996         }
19997 
19998         CHECK_EXCEPTION();
19999         ZEND_VM_NEXT_OPCODE();
20000 }
20001 
20002 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20003 {
20004         USE_OPLINE
20005         zend_free_op free_op1, free_op2;
20006         zval *property;
20007         zval **container;
20008 
20009         SAVE_OPLINE();
20010         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20011         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20012 
20013         if (0) {
20014                 MAKE_REAL_ZVAL_PTR(property);
20015         }
20016         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
20017                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20018         }
20019         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
20020         if (0) {
20021                 zval_ptr_dtor(&property);
20022         } else {
20023                 zval_ptr_dtor_nogc(&free_op2.var);
20024         }
20025         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
20026                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
20027         }
20028         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20029         CHECK_EXCEPTION();
20030         ZEND_VM_NEXT_OPCODE();
20031 }
20032 
20033 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20034 {
20035         USE_OPLINE
20036         zend_free_op free_op1;
20037         zval *container;
20038         zend_free_op free_op2;
20039         zval *offset;
20040 
20041         SAVE_OPLINE();
20042         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20043         offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20044 
20045         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
20046             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
20047                 PZVAL_LOCK(&EG(uninitialized_zval));
20048                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20049                 zval_ptr_dtor_nogc(&free_op2.var);
20050         } else {
20051                 zval *retval;
20052 
20053                 if (0) {
20054                         MAKE_REAL_ZVAL_PTR(offset);
20055                 }
20056 
20057                 /* here we are sure we are dealing with an object */
20058                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20059 
20060                 PZVAL_LOCK(retval);
20061                 EX_T(opline->result.var).var.ptr = retval;
20062 
20063                 if (0) {
20064                         zval_ptr_dtor(&offset);
20065                 } else {
20066                         zval_ptr_dtor_nogc(&free_op2.var);
20067                 }
20068         }
20069 
20070         zval_ptr_dtor_nogc(&free_op1.var);
20071         CHECK_EXCEPTION();
20072         ZEND_VM_NEXT_OPCODE();
20073 }
20074 
20075 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20076 {
20077         USE_OPLINE
20078 
20079         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
20080                 /* Behave like FETCH_OBJ_W */
20081                 zend_free_op free_op1, free_op2;
20082                 zval *property;
20083                 zval **container;
20084 
20085                 SAVE_OPLINE();
20086                 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20087                 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20088 
20089                 if (0) {
20090                         MAKE_REAL_ZVAL_PTR(property);
20091                 }
20092                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
20093                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20094                 }
20095                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
20096                 if (0) {
20097                         zval_ptr_dtor(&property);
20098                 } else {
20099                         zval_ptr_dtor_nogc(&free_op2.var);
20100                 }
20101                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
20102                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
20103                 }
20104                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20105                 CHECK_EXCEPTION();
20106                 ZEND_VM_NEXT_OPCODE();
20107         } else {
20108                 return zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20109         }
20110 }
20111 
20112 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20113 {
20114         USE_OPLINE
20115         zend_free_op free_op1, free_op2, free_res;
20116         zval **container;
20117         zval *property;
20118 
20119         SAVE_OPLINE();
20120         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20121         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20122 
20123         if (IS_VAR == IS_CV) {
20124                 if (container != &EG(uninitialized_zval_ptr)) {
20125                         SEPARATE_ZVAL_IF_NOT_REF(container);
20126                 }
20127         }
20128         if (0) {
20129                 MAKE_REAL_ZVAL_PTR(property);
20130         }
20131         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
20132                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
20133         }
20134         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
20135         if (0) {
20136                 zval_ptr_dtor(&property);
20137         } else {
20138                 zval_ptr_dtor_nogc(&free_op2.var);
20139         }
20140         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
20141                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
20142         }
20143         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20144 
20145         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
20146         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
20147                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
20148         }
20149         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
20150         FREE_OP_VAR_PTR(free_res);
20151         CHECK_EXCEPTION();
20152         ZEND_VM_NEXT_OPCODE();
20153 }
20154 
20155 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20156 {
20157         USE_OPLINE
20158         zend_free_op free_op1, free_op2;
20159         zval **object_ptr;
20160         zval *property_name;
20161 
20162         SAVE_OPLINE();
20163         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20164         property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20165 
20166         if (0) {
20167                 MAKE_REAL_ZVAL_PTR(property_name);
20168         }
20169         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
20170                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
20171         }
20172         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20173         if (0) {
20174                 zval_ptr_dtor(&property_name);
20175         } else {
20176                 zval_ptr_dtor_nogc(&free_op2.var);
20177         }
20178         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20179         /* assign_obj has two opcodes! */
20180         CHECK_EXCEPTION();
20181         ZEND_VM_INC_OPCODE();
20182         ZEND_VM_NEXT_OPCODE();
20183 }
20184 
20185 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20186 {
20187         USE_OPLINE
20188         zend_free_op free_op1;
20189         zval **object_ptr;
20190 
20191         SAVE_OPLINE();
20192         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20193 
20194         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
20195                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
20196         }
20197         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
20198                 zend_free_op free_op2;
20199                 zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20200 
20201                 if (0) {
20202                         MAKE_REAL_ZVAL_PTR(property_name);
20203                 }
20204                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20205                 if (0) {
20206                         zval_ptr_dtor(&property_name);
20207                 } else {
20208                         zval_ptr_dtor_nogc(&free_op2.var);
20209                 }
20210         } else {
20211                 zend_free_op free_op2, free_op_data1, free_op_data2;
20212                 zval *value;
20213                 zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20214                 zval **variable_ptr_ptr;
20215 
20216                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC);
20217                 zval_ptr_dtor_nogc(&free_op2.var);
20218 
20219                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
20220                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
20221                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
20222                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
20223                                 if (RETURN_VALUE_USED(opline)) {
20224                                         zval *retval;
20225 
20226                                         ALLOC_ZVAL(retval);
20227                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
20228                                         INIT_PZVAL(retval);
20229                                         EX_T(opline->result.var).var.ptr = retval;
20230                                 }
20231                         } else if (RETURN_VALUE_USED(opline)) {
20232                                 PZVAL_LOCK(&EG(uninitialized_zval));
20233                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20234                         }
20235                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
20236                         if (IS_TMP_FREE(free_op_data1)) {
20237                                 zval_dtor(value);
20238                         }
20239                         if (RETURN_VALUE_USED(opline)) {
20240                                 PZVAL_LOCK(&EG(uninitialized_zval));
20241                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20242                         }
20243                 } else {
20244                         if ((opline+1)->op1_type == IS_TMP_VAR) {
20245                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20246                         } else if ((opline+1)->op1_type == IS_CONST) {
20247                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20248                         } else {
20249                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20250                         }
20251                         if (RETURN_VALUE_USED(opline)) {
20252                                 PZVAL_LOCK(value);
20253                                 EX_T(opline->result.var).var.ptr = value;
20254                         }
20255                 }
20256                 FREE_OP_VAR_PTR(free_op_data2);
20257                 FREE_OP_IF_VAR(free_op_data1);
20258         }
20259         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20260         /* assign_dim has two opcodes! */
20261         CHECK_EXCEPTION();
20262         ZEND_VM_INC_OPCODE();
20263         ZEND_VM_NEXT_OPCODE();
20264 }
20265 
20266 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20267 {
20268         USE_OPLINE
20269         zend_free_op free_op1, free_op2;
20270         zval *value;
20271         zval **variable_ptr_ptr;
20272 
20273         SAVE_OPLINE();
20274         value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20275         variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20276 
20277         if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
20278                 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) {
20279                         if (RETURN_VALUE_USED(opline)) {
20280                                 zval *retval;
20281 
20282                                 ALLOC_ZVAL(retval);
20283                                 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
20284                                 INIT_PZVAL(retval);
20285                                 EX_T(opline->result.var).var.ptr = retval;
20286                         }
20287                 } else if (RETURN_VALUE_USED(opline)) {
20288                         PZVAL_LOCK(&EG(uninitialized_zval));
20289                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20290                 }
20291         } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
20292                 if (0) {
20293                         zval_dtor(value);
20294                 }
20295                 if (RETURN_VALUE_USED(opline)) {
20296                         PZVAL_LOCK(&EG(uninitialized_zval));
20297                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
20298                 }
20299         } else {
20300                 if (IS_VAR == IS_TMP_VAR) {
20301                         value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20302                 } else if (IS_VAR == IS_CONST) {
20303                         value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20304                 } else {
20305                         value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
20306                 }
20307                 if (RETURN_VALUE_USED(opline)) {
20308                         PZVAL_LOCK(value);
20309                         EX_T(opline->result.var).var.ptr = value;
20310                 }
20311         }
20312 
20313         if (IS_VAR == IS_VAR && (free_op1.var != NULL)) {
20314                 zval_ptr_dtor_nogc(&value);
20315         }
20316 
20317         /* zend_assign_to_variable() always takes care of op2, never free it! */
20318         zval_ptr_dtor_nogc(&free_op2.var);
20319 
20320         CHECK_EXCEPTION();
20321         ZEND_VM_NEXT_OPCODE();
20322 }
20323 
20324 static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20325 {
20326         USE_OPLINE
20327         zend_free_op free_op1, free_op2;
20328         zval **variable_ptr_ptr;
20329         zval **value_ptr_ptr;
20330 
20331         SAVE_OPLINE();
20332         value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20333 
20334         if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
20335                 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
20336         }
20337 
20338         if (IS_VAR == IS_VAR &&
20339             value_ptr_ptr &&
20340             !Z_ISREF_PP(value_ptr_ptr) &&
20341             opline->extended_value == ZEND_RETURNS_FUNCTION &&
20342             !EX_T(opline->op2.var).var.fcall_returned_reference) {
20343                 if (free_op2.var == NULL) {
20344                         PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
20345                 }
20346                 zend_error(E_STRICT, "Only variables should be assigned by reference");
20347                 if (UNEXPECTED(EG(exception) != NULL)) {
20348                         if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
20349                         HANDLE_EXCEPTION();
20350                 }
20351                 return ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20352         } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
20353                 PZVAL_LOCK(*value_ptr_ptr);
20354         }
20355 
20356         variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20357         if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
20358             (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
20359                 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
20360         }
20361         zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
20362 
20363         if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
20364                 Z_DELREF_PP(variable_ptr_ptr);
20365         }
20366 
20367         if (RETURN_VALUE_USED(opline)) {
20368                 PZVAL_LOCK(*variable_ptr_ptr);
20369                 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
20370         }
20371 
20372         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20373         if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
20374 
20375         CHECK_EXCEPTION();
20376         ZEND_VM_NEXT_OPCODE();
20377 }
20378 
20379 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20380 {
20381         USE_OPLINE
20382         zval *function_name;
20383         char *function_name_strval;
20384         int function_name_strlen;
20385         zend_free_op free_op1, free_op2;
20386         call_slot *call = EX(call_slots) + opline->result.num;
20387 
20388         SAVE_OPLINE();
20389 
20390         function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20391 
20392         if (IS_VAR != IS_CONST &&
20393             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
20394                 if (UNEXPECTED(EG(exception) != NULL)) {
20395                         HANDLE_EXCEPTION();
20396                 }
20397                 zend_error_noreturn(E_ERROR, "Method name must be a string");
20398         }
20399 
20400         function_name_strval = Z_STRVAL_P(function_name);
20401         function_name_strlen = Z_STRLEN_P(function_name);
20402 
20403         call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20404 
20405         if (EXPECTED(call->object != NULL) &&
20406             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
20407                 call->called_scope = Z_OBJCE_P(call->object);
20408 
20409                 if (IS_VAR != IS_CONST ||
20410                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
20411                     zval *object = call->object;
20412 
20413                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
20414                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
20415                         }
20416 
20417                         /* First, locate the function. */
20418                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
20419                         if (UNEXPECTED(call->fbc == NULL)) {
20420                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
20421                         }
20422                         if (IS_VAR == IS_CONST &&
20423                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
20424                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
20425                             EXPECTED(call->object == object)) {
20426                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
20427                         }
20428                 }
20429         } else {
20430                 if (UNEXPECTED(EG(exception) != NULL)) {
20431                         zval_ptr_dtor_nogc(&free_op2.var);
20432                         HANDLE_EXCEPTION();
20433                 }
20434                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
20435         }
20436 
20437         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
20438                 call->object = NULL;
20439         } else {
20440                 if (!PZVAL_IS_REF(call->object)) {
20441                         Z_ADDREF_P(call->object); /* For $this pointer */
20442                 } else {
20443                         zval *this_ptr;
20444                         ALLOC_ZVAL(this_ptr);
20445                         INIT_PZVAL_COPY(this_ptr, call->object);
20446                         zval_copy_ctor(this_ptr);
20447                         call->object = this_ptr;
20448                 }
20449         }
20450 
20451         call->num_additional_args = 0;
20452         call->is_ctor_call = 0;
20453         EX(call) = call;
20454 
20455         zval_ptr_dtor_nogc(&free_op2.var);
20456         zval_ptr_dtor_nogc(&free_op1.var);
20457 
20458         CHECK_EXCEPTION();
20459         ZEND_VM_NEXT_OPCODE();
20460 }
20461 
20462 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20463 {
20464         USE_OPLINE
20465         zval *function_name;
20466         zend_class_entry *ce;
20467         call_slot *call = EX(call_slots) + opline->result.num;
20468 
20469         SAVE_OPLINE();
20470 
20471         if (IS_VAR == IS_CONST) {
20472                 /* no function found. try a static method in class */
20473                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
20474                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
20475                 } else {
20476                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
20477                         if (UNEXPECTED(EG(exception) != NULL)) {
20478                                 HANDLE_EXCEPTION();
20479                         }
20480                         if (UNEXPECTED(ce == NULL)) {
20481                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
20482                         }
20483                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
20484                 }
20485                 call->called_scope = ce;
20486         } else {
20487                 ce = EX_T(opline->op1.var).class_entry;
20488 
20489                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
20490                         call->called_scope = EG(called_scope);
20491                 } else {
20492                         call->called_scope = ce;
20493                 }
20494         }
20495 
20496         if (IS_VAR == IS_CONST &&
20497             IS_VAR == IS_CONST &&
20498             CACHED_PTR(opline->op2.literal->cache_slot)) {
20499                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
20500         } else if (IS_VAR != IS_CONST &&
20501                    IS_VAR == IS_CONST &&
20502                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
20503                 /* do nothing */
20504         } else if (IS_VAR != IS_UNUSED) {
20505                 char *function_name_strval = NULL;
20506                 int function_name_strlen = 0;
20507                 zend_free_op free_op2;
20508 
20509                 if (IS_VAR == IS_CONST) {
20510                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
20511                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
20512                 } else {
20513                         function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20514 
20515                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
20516                                 if (UNEXPECTED(EG(exception) != NULL)) {
20517                                         HANDLE_EXCEPTION();
20518                                 }
20519                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
20520                         } else {
20521                                 function_name_strval = Z_STRVAL_P(function_name);
20522                                 function_name_strlen = Z_STRLEN_P(function_name);
20523                         }
20524                 }
20525 
20526                 if (function_name_strval) {
20527                         if (ce->get_static_method) {
20528                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
20529                         } else {
20530                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
20531                         }
20532                         if (UNEXPECTED(call->fbc == NULL)) {
20533                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
20534                         }
20535                         if (IS_VAR == IS_CONST &&
20536                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
20537                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
20538                                 if (IS_VAR == IS_CONST) {
20539                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
20540                                 } else {
20541                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
20542                                 }
20543                         }
20544                 }
20545                 if (IS_VAR != IS_CONST) {
20546                         zval_ptr_dtor_nogc(&free_op2.var);
20547                 }
20548         } else {
20549                 if (UNEXPECTED(ce->constructor == NULL)) {
20550                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
20551                 }
20552                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
20553                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
20554                 }
20555                 call->fbc = ce->constructor;
20556         }
20557 
20558         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
20559                 call->object = NULL;
20560         } else {
20561                 if (EG(This) &&
20562                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
20563                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
20564                     /* We are calling method of the other (incompatible) class,
20565                        but passing $this. This is done for compatibility with php-4. */
20566                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
20567                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
20568                         } else {
20569                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
20570                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
20571                         }
20572                 }
20573                 if ((call->object = EG(This))) {
20574                         Z_ADDREF_P(call->object);
20575                         call->called_scope = Z_OBJCE_P(call->object);
20576                 }
20577         }
20578 
20579         call->num_additional_args = 0;
20580         call->is_ctor_call = 0;
20581         EX(call) = call;
20582 
20583         CHECK_EXCEPTION();
20584         ZEND_VM_NEXT_OPCODE();
20585 }
20586 
20587 static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20588 {
20589         USE_OPLINE
20590         zend_free_op free_op1, free_op2;
20591 
20592         SAVE_OPLINE();
20593         is_equal_function(&EX_T(opline->result.var).tmp_var,
20594                                  _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
20595                                  _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
20596 
20597         zval_ptr_dtor_nogc(&free_op2.var);
20598         CHECK_EXCEPTION();
20599         ZEND_VM_NEXT_OPCODE();
20600 }
20601 
20602 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20603 {
20604         USE_OPLINE
20605         zend_free_op free_op1;
20606         zval *expr_ptr;
20607 
20608         SAVE_OPLINE();
20609         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
20610                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20611 
20612                 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
20613                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
20614                 }
20615                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
20616                 expr_ptr = *expr_ptr_ptr;
20617                 Z_ADDREF_P(expr_ptr);
20618         } else {
20619                 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20620                 if (0) { /* temporary variable */
20621                         zval *new_expr;
20622 
20623                         ALLOC_ZVAL(new_expr);
20624                         INIT_PZVAL_COPY(new_expr, expr_ptr);
20625                         expr_ptr = new_expr;
20626                 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
20627                         zval *new_expr;
20628 
20629                         ALLOC_ZVAL(new_expr);
20630                         INIT_PZVAL_COPY(new_expr, expr_ptr);
20631                         expr_ptr = new_expr;
20632                         zendi_zval_copy_ctor(*expr_ptr);
20633                         zval_ptr_dtor_nogc(&free_op1.var);
20634                 } else if (IS_VAR == IS_CV) {
20635                         Z_ADDREF_P(expr_ptr);
20636                 }
20637         }
20638 
20639         if (IS_VAR != IS_UNUSED) {
20640                 zend_free_op free_op2;
20641                 zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20642                 ulong hval;
20643 
20644                 switch (Z_TYPE_P(offset)) {
20645                         case IS_DOUBLE:
20646                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
20647                                 goto num_index;
20648                         case IS_LONG:
20649                         case IS_BOOL:
20650                                 hval = Z_LVAL_P(offset);
20651 num_index:
20652                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
20653                                 break;
20654                         case IS_STRING:
20655                                 if (IS_VAR == IS_CONST) {
20656                                         hval = Z_HASH_P(offset);
20657                                 } else {
20658                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
20659                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
20660                                 }
20661                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
20662                                 break;
20663                         case IS_NULL:
20664                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
20665                                 break;
20666                         default:
20667                                 zend_error(E_WARNING, "Illegal offset type");
20668                                 zval_ptr_dtor(&expr_ptr);
20669                                 /* do nothing */
20670                                 break;
20671                 }
20672                 zval_ptr_dtor_nogc(&free_op2.var);
20673         } else {
20674                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
20675         }
20676         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
20677                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20678         }
20679         CHECK_EXCEPTION();
20680         ZEND_VM_NEXT_OPCODE();
20681 }
20682 
20683 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20684 {
20685         USE_OPLINE
20686 
20687         array_init(&EX_T(opline->result.var).tmp_var);
20688         if (IS_VAR == IS_UNUSED) {
20689                 ZEND_VM_NEXT_OPCODE();
20690 #if 0 || IS_VAR != IS_UNUSED
20691         } else {
20692                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
20693 #endif
20694         }
20695 }
20696 
20697 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20698 {
20699         USE_OPLINE
20700         zval tmp, *varname;
20701         HashTable *target_symbol_table;
20702         zend_free_op free_op1;
20703 
20704         SAVE_OPLINE();
20705         if (IS_VAR == IS_CV &&
20706             IS_VAR == IS_UNUSED &&
20707             (opline->extended_value & ZEND_QUICK_SET)) {
20708                 if (EG(active_symbol_table)) {
20709                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
20710 
20711                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
20712                         EX_CV(opline->op1.var) = NULL;
20713                 } else if (EX_CV(opline->op1.var)) {
20714                         zval_ptr_dtor(EX_CV(opline->op1.var));
20715                         EX_CV(opline->op1.var) = NULL;
20716                 }
20717                 CHECK_EXCEPTION();
20718                 ZEND_VM_NEXT_OPCODE();
20719         }
20720 
20721         varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20722 
20723         if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
20724                 ZVAL_COPY_VALUE(&tmp, varname);
20725                 zval_copy_ctor(&tmp);
20726                 convert_to_string(&tmp);
20727                 varname = &tmp;
20728         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
20729                 Z_ADDREF_P(varname);
20730         }
20731 
20732         if (IS_VAR != IS_UNUSED) {
20733                 zend_class_entry *ce;
20734 
20735                 if (IS_VAR == IS_CONST) {
20736                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
20737                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
20738                         } else {
20739                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
20740                                 if (UNEXPECTED(EG(exception) != NULL)) {
20741                                         if (IS_VAR != IS_CONST && varname == &tmp) {
20742                                                 zval_dtor(&tmp);
20743                                         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
20744                                                 zval_ptr_dtor(&varname);
20745                                         }
20746                                         zval_ptr_dtor_nogc(&free_op1.var);
20747                                         HANDLE_EXCEPTION();
20748                                 }
20749                                 if (UNEXPECTED(ce == NULL)) {
20750                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
20751                                 }
20752                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
20753                         }
20754                 } else {
20755                         ce = EX_T(opline->op2.var).class_entry;
20756                 }
20757                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
20758         } else {
20759                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
20760 
20761                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
20762                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
20763         }
20764 
20765         if (IS_VAR != IS_CONST && varname == &tmp) {
20766                 zval_dtor(&tmp);
20767         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
20768                 zval_ptr_dtor(&varname);
20769         }
20770         zval_ptr_dtor_nogc(&free_op1.var);
20771         CHECK_EXCEPTION();
20772         ZEND_VM_NEXT_OPCODE();
20773 }
20774 
20775 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20776 {
20777         USE_OPLINE
20778         zend_free_op free_op1, free_op2;
20779         zval **container;
20780         zval *offset;
20781         ulong hval;
20782 
20783         SAVE_OPLINE();
20784         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20785         if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
20786                 SEPARATE_ZVAL_IF_NOT_REF(container);
20787         }
20788         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20789 
20790         if (IS_VAR != IS_VAR || container) {
20791                 switch (Z_TYPE_PP(container)) {
20792                         case IS_ARRAY: {
20793                                 HashTable *ht = Z_ARRVAL_PP(container);
20794 
20795                                 switch (Z_TYPE_P(offset)) {
20796                                         case IS_DOUBLE:
20797                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
20798                                                 zend_hash_index_del(ht, hval);
20799                                                 break;
20800                                         case IS_RESOURCE:
20801                                         case IS_BOOL:
20802                                         case IS_LONG:
20803                                                 hval = Z_LVAL_P(offset);
20804                                                 zend_hash_index_del(ht, hval);
20805                                                 break;
20806                                         case IS_STRING:
20807                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
20808                                                         Z_ADDREF_P(offset);
20809                                                 }
20810                                                 if (IS_VAR == IS_CONST) {
20811                                                         hval = Z_HASH_P(offset);
20812                                                 } else {
20813                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
20814                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
20815                                                 }
20816                                                 if (ht == &EG(symbol_table)) {
20817                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
20818                                                 } else {
20819                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
20820                                                 }
20821                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
20822                                                         zval_ptr_dtor(&offset);
20823                                                 }
20824                                                 break;
20825 num_index_dim:
20826                                                 zend_hash_index_del(ht, hval);
20827                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
20828                                                         zval_ptr_dtor(&offset);
20829                                                 }
20830                                                 break;
20831                                         case IS_NULL:
20832                                                 zend_hash_del(ht, "", sizeof(""));
20833                                                 break;
20834                                         default:
20835                                                 zend_error(E_WARNING, "Illegal offset type in unset");
20836                                                 break;
20837                                 }
20838                                 zval_ptr_dtor_nogc(&free_op2.var);
20839                                 break;
20840                         }
20841                         case IS_OBJECT:
20842                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
20843                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
20844                                 }
20845                                 if (0) {
20846                                         MAKE_REAL_ZVAL_PTR(offset);
20847                                 }
20848                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
20849                                 if (0) {
20850                                         zval_ptr_dtor(&offset);
20851                                 } else {
20852                                         zval_ptr_dtor_nogc(&free_op2.var);
20853                                 }
20854                                 break;
20855                         case IS_STRING:
20856                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
20857                                 ZEND_VM_CONTINUE(); /* bailed out before */
20858                         default:
20859                                 zval_ptr_dtor_nogc(&free_op2.var);
20860                                 break;
20861                 }
20862         } else {
20863                 zval_ptr_dtor_nogc(&free_op2.var);
20864         }
20865         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20866 
20867         CHECK_EXCEPTION();
20868         ZEND_VM_NEXT_OPCODE();
20869 }
20870 
20871 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20872 {
20873         USE_OPLINE
20874         zend_free_op free_op1, free_op2;
20875         zval **container;
20876         zval *offset;
20877 
20878         SAVE_OPLINE();
20879         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20880         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
20881 
20882         if (IS_VAR != IS_VAR || container) {
20883                 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
20884                         SEPARATE_ZVAL_IF_NOT_REF(container);
20885                 }
20886                 if (Z_TYPE_PP(container) == IS_OBJECT) {
20887                         if (0) {
20888                                 MAKE_REAL_ZVAL_PTR(offset);
20889                         }
20890                         if (Z_OBJ_HT_P(*container)->unset_property) {
20891                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
20892                         } else {
20893                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
20894                         }
20895                         if (0) {
20896                                 zval_ptr_dtor(&offset);
20897                         } else {
20898                                 zval_ptr_dtor_nogc(&free_op2.var);
20899                         }
20900                 } else {
20901                         zval_ptr_dtor_nogc(&free_op2.var);
20902                 }
20903         } else {
20904                 zval_ptr_dtor_nogc(&free_op2.var);
20905         }
20906         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
20907 
20908         CHECK_EXCEPTION();
20909         ZEND_VM_NEXT_OPCODE();
20910 }
20911 
20912 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20913 {
20914         USE_OPLINE
20915         zval **value;
20916         zend_bool isset = 1;
20917 
20918         SAVE_OPLINE();
20919         if (IS_VAR == IS_CV &&
20920             IS_VAR == IS_UNUSED &&
20921             (opline->extended_value & ZEND_QUICK_SET)) {
20922                 if (EX_CV(opline->op1.var)) {
20923                         value = EX_CV(opline->op1.var);
20924                 } else if (EG(active_symbol_table)) {
20925                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
20926 
20927                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
20928                                 isset = 0;
20929                         }
20930                 } else {
20931                         isset = 0;
20932                 }
20933         } else {
20934                 HashTable *target_symbol_table;
20935                 zend_free_op free_op1;
20936                 zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
20937 
20938                 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
20939                         ZVAL_COPY_VALUE(&tmp, varname);
20940                         zval_copy_ctor(&tmp);
20941                         convert_to_string(&tmp);
20942                         varname = &tmp;
20943                 }
20944 
20945                 if (IS_VAR != IS_UNUSED) {
20946                         zend_class_entry *ce;
20947 
20948                         if (IS_VAR == IS_CONST) {
20949                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
20950                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
20951                                 } else {
20952                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
20953                                         if (UNEXPECTED(ce == NULL)) {
20954                                                 CHECK_EXCEPTION();
20955                                                 ZEND_VM_NEXT_OPCODE();
20956                                         }
20957                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
20958                                 }
20959                         } else {
20960                                 ce = EX_T(opline->op2.var).class_entry;
20961                         }
20962                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
20963                         if (!value) {
20964                                 isset = 0;
20965                         }
20966                 } else {
20967                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
20968                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
20969                                 isset = 0;
20970                         }
20971                 }
20972 
20973                 if (IS_VAR != IS_CONST && varname == &tmp) {
20974                         zval_dtor(&tmp);
20975                 }
20976                 zval_ptr_dtor_nogc(&free_op1.var);
20977         }
20978 
20979         if (opline->extended_value & ZEND_ISSET) {
20980                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
20981                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
20982                 } else {
20983                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
20984                 }
20985         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
20986                 if (!isset || !i_zend_is_true(*value)) {
20987                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
20988                 } else {
20989                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
20990                 }
20991         }
20992 
20993         CHECK_EXCEPTION();
20994         ZEND_VM_NEXT_OPCODE();
20995 }
20996 
20997 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
20998 {
20999         USE_OPLINE
21000         zend_free_op free_op1, free_op2;
21001         zval *container;
21002         zval **value = NULL;
21003         int result = 0;
21004         ulong hval;
21005         zval *offset;
21006 
21007         SAVE_OPLINE();
21008         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21009         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
21010 
21011         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
21012                 HashTable *ht;
21013                 int isset = 0;
21014 
21015                 ht = Z_ARRVAL_P(container);
21016 
21017                 switch (Z_TYPE_P(offset)) {
21018                         case IS_DOUBLE:
21019                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
21020                                 goto num_index_prop;
21021                         case IS_RESOURCE:
21022                         case IS_BOOL:
21023                         case IS_LONG:
21024                                 hval = Z_LVAL_P(offset);
21025 num_index_prop:
21026                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
21027                                         isset = 1;
21028                                 }
21029                                 break;
21030                         case IS_STRING:
21031                                 if (IS_VAR == IS_CONST) {
21032                                         hval = Z_HASH_P(offset);
21033                                 } else {
21034                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
21035                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
21036                                 }
21037                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
21038                                         isset = 1;
21039                                 }
21040                                 break;
21041                         case IS_NULL:
21042                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
21043                                         isset = 1;
21044                                 }
21045                                 break;
21046                         default:
21047                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
21048                                 break;
21049                 }
21050 
21051                 if (opline->extended_value & ZEND_ISSET) {
21052                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
21053                                 result = 0;
21054                         } else {
21055                                 result = isset;
21056                         }
21057                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
21058                         if (!isset || !i_zend_is_true(*value)) {
21059                                 result = 0;
21060                         } else {
21061                                 result = 1;
21062                         }
21063                 }
21064                 zval_ptr_dtor_nogc(&free_op2.var);
21065         } else if (Z_TYPE_P(container) == IS_OBJECT) {
21066                 if (0) {
21067                         MAKE_REAL_ZVAL_PTR(offset);
21068                 }
21069                 if (prop_dim) {
21070                         if (Z_OBJ_HT_P(container)->has_property) {
21071                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21072                         } else {
21073                                 zend_error(E_NOTICE, "Trying to check property of non-object");
21074                                 result = 0;
21075                         }
21076                 } else {
21077                         if (Z_OBJ_HT_P(container)->has_dimension) {
21078                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
21079                         } else {
21080                                 zend_error(E_NOTICE, "Trying to check element of non-array");
21081                                 result = 0;
21082                         }
21083                 }
21084                 if (0) {
21085                         zval_ptr_dtor(&offset);
21086                 } else {
21087                         zval_ptr_dtor_nogc(&free_op2.var);
21088                 }
21089         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
21090                 zval tmp;
21091 
21092                 if (Z_TYPE_P(offset) != IS_LONG) {
21093                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
21094                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
21095                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
21096                                 ZVAL_COPY_VALUE(&tmp, offset);
21097                                 zval_copy_ctor(&tmp);
21098                                 convert_to_long(&tmp);
21099                                 offset = &tmp;
21100                         } else {
21101                                 /* can not be converted to proper offset, return "not set" */
21102                                 result = 0;
21103                         }
21104                 }
21105                 if (Z_TYPE_P(offset) == IS_LONG) {
21106                         if (opline->extended_value & ZEND_ISSET) {
21107                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
21108                                         result = 1;
21109                                 }
21110                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
21111                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
21112                                         result = 1;
21113                                 }
21114                         }
21115                 }
21116                 zval_ptr_dtor_nogc(&free_op2.var);
21117         } else {
21118                 zval_ptr_dtor_nogc(&free_op2.var);
21119         }
21120 
21121         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
21122         if (opline->extended_value & ZEND_ISSET) {
21123                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
21124         } else {
21125                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
21126         }
21127 
21128         zval_ptr_dtor_nogc(&free_op1.var);
21129 
21130         CHECK_EXCEPTION();
21131         ZEND_VM_NEXT_OPCODE();
21132 }
21133 
21134 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21135 {
21136         return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21137 }
21138 
21139 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21140 {
21141         return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21142 }
21143 
21144 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21145 {
21146         USE_OPLINE
21147 
21148         /* The generator object is stored in return_value_ptr_ptr */
21149         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
21150 
21151         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
21152                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
21153         }
21154 
21155         /* Destroy the previously yielded value */
21156         if (generator->value) {
21157                 zval_ptr_dtor(&generator->value);
21158         }
21159 
21160         /* Destroy the previously yielded key */
21161         if (generator->key) {
21162                 zval_ptr_dtor(&generator->key);
21163         }
21164 
21165         /* Set the new yielded value */
21166         if (IS_VAR != IS_UNUSED) {
21167                 zend_free_op free_op1;
21168 
21169                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
21170                         /* Constants and temporary variables aren't yieldable by reference,
21171                          * but we still allow them with a notice. */
21172                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
21173                                 zval *value, *copy;
21174 
21175                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21176 
21177                                 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21178                                 ALLOC_ZVAL(copy);
21179                                 INIT_PZVAL_COPY(copy, value);
21180 
21181                                 /* Temporary variables don't need ctor copying */
21182                                 if (!0) {
21183                                         zval_copy_ctor(copy);
21184                                 }
21185 
21186                                 generator->value = copy;
21187                         } else {
21188                                 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21189 
21190                                 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
21191                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
21192                                 }
21193 
21194                                 /* If a function call result is yielded and the function did
21195                                  * not return by reference we throw a notice. */
21196                                 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
21197                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
21198                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
21199                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
21200                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21201 
21202                                         Z_ADDREF_PP(value_ptr);
21203                                         generator->value = *value_ptr;
21204                                 } else {
21205                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
21206                                         Z_ADDREF_PP(value_ptr);
21207                                         generator->value = *value_ptr;
21208                                 }
21209 
21210                                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21211                         }
21212                 } else {
21213                         zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21214 
21215                         /* Consts, temporary variables and references need copying */
21216                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
21217                                 || PZVAL_IS_REF(value)
21218                         ) {
21219                                 zval *copy;
21220 
21221                                 ALLOC_ZVAL(copy);
21222                                 INIT_PZVAL_COPY(copy, value);
21223 
21224                                 /* Temporary variables don't need ctor copying */
21225                                 if (!0) {
21226                                         zval_copy_ctor(copy);
21227                                 }
21228 
21229                                 generator->value = copy;
21230                                 zval_ptr_dtor_nogc(&free_op1.var);
21231                         } else {
21232                                 if (IS_VAR == IS_CV) {
21233                                         Z_ADDREF_P(value);
21234                                 }
21235                                 generator->value = value;
21236                         }
21237                 }
21238         } else {
21239                 /* If no value was specified yield null */
21240                 Z_ADDREF(EG(uninitialized_zval));
21241                 generator->value = &EG(uninitialized_zval);
21242         }
21243 
21244         /* Set the new yielded key */
21245         if (IS_VAR != IS_UNUSED) {
21246                 zend_free_op free_op2;
21247                 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
21248 
21249                 /* Consts, temporary variables and references need copying */
21250                 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
21251                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
21252                 ) {
21253                         zval *copy;
21254 
21255                         ALLOC_ZVAL(copy);
21256                         INIT_PZVAL_COPY(copy, key);
21257 
21258                         /* Temporary variables don't need ctor copying */
21259                         if (!0) {
21260                                 zval_copy_ctor(copy);
21261                         }
21262 
21263                         generator->key = copy;
21264                 } else {
21265                         Z_ADDREF_P(key);
21266                         generator->key = key;
21267                 }
21268 
21269                 if (Z_TYPE_P(generator->key) == IS_LONG
21270                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
21271                 ) {
21272                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
21273                 }
21274 
21275                 zval_ptr_dtor_nogc(&free_op2.var);
21276         } else {
21277                 /* If no key was specified we use auto-increment keys */
21278                 generator->largest_used_integer_key++;
21279 
21280                 ALLOC_INIT_ZVAL(generator->key);
21281                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
21282         }
21283 
21284         if (RETURN_VALUE_USED(opline)) {
21285                 /* If the return value of yield is used set the send
21286                  * target and initialize it to NULL */
21287                 generator->send_target = &EX_T(opline->result.var).var.ptr;
21288                 Z_ADDREF(EG(uninitialized_zval));
21289                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21290         } else {
21291                 generator->send_target = NULL;
21292         }
21293 
21294         /* We increment to the next op, so we are at the correct position when the
21295          * generator is resumed. */
21296         ZEND_VM_INC_OPCODE();
21297 
21298         /* The GOTO VM uses a local opline variable. We need to set the opline
21299          * variable in execute_data so we don't resume at an old position. */
21300         SAVE_OPLINE();
21301 
21302         ZEND_VM_RETURN();
21303 }
21304 
21305 static int ZEND_FASTCALL  ZEND_POW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21306 {
21307         USE_OPLINE
21308         zend_free_op free_op1, free_op2;
21309 
21310         SAVE_OPLINE();
21311         pow_function(&EX_T(opline->result.var).tmp_var,
21312                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
21313                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
21314         zval_ptr_dtor_nogc(&free_op1.var);
21315         zval_ptr_dtor_nogc(&free_op2.var);
21316         CHECK_EXCEPTION();
21317         ZEND_VM_NEXT_OPCODE();
21318 }
21319 
21320 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21321 {
21322         return zend_binary_assign_op_helper_SPEC_VAR_VAR(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21323 }
21324 
21325 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
21326 {
21327         USE_OPLINE
21328         zend_free_op free_op1, free_op_data1;
21329         zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21330         zval *object;
21331         zval *property = NULL;
21332         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
21333         int have_get_ptr = 0;
21334 
21335         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
21336                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
21337         }
21338 
21339         make_real_object(object_ptr TSRMLS_CC);
21340         object = *object_ptr;
21341 
21342         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
21343                 zend_error(E_WARNING, "Attempt to assign property of non-object");
21344 
21345                 FREE_OP(free_op_data1);
21346 
21347                 if (RETURN_VALUE_USED(opline)) {
21348                         PZVAL_LOCK(&EG(uninitialized_zval));
21349                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21350                 }
21351         } else {
21352                 /* here we are sure we are dealing with an object */
21353                 if (0) {
21354                         MAKE_REAL_ZVAL_PTR(property);
21355                 }
21356 
21357                 /* here property is a string */
21358                 if (opline->extended_value == ZEND_ASSIGN_OBJ
21359                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
21360                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21361                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
21362                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
21363 
21364                                 have_get_ptr = 1;
21365                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
21366                                 if (RETURN_VALUE_USED(opline)) {
21367                                         PZVAL_LOCK(*zptr);
21368                                         EX_T(opline->result.var).var.ptr = *zptr;
21369                                 }
21370                         }
21371                 }
21372 
21373                 if (!have_get_ptr) {
21374                         zval *z = NULL;
21375 
21376                         Z_ADDREF_P(object);
21377                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
21378                                 if (Z_OBJ_HT_P(object)->read_property) {
21379                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21380                                 }
21381                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
21382                                 if (Z_OBJ_HT_P(object)->read_dimension) {
21383                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
21384                                 }
21385                         }
21386                         if (z) {
21387                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
21388                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
21389 
21390                                         if (Z_REFCOUNT_P(z) == 0) {
21391                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
21392                                                 zval_dtor(z);
21393                                                 FREE_ZVAL(z);
21394                                         }
21395                                         z = value;
21396                                 }
21397                                 Z_ADDREF_P(z);
21398                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
21399                                 binary_op(z, z, value TSRMLS_CC);
21400                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
21401                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21402                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
21403                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
21404                                 }
21405                                 if (RETURN_VALUE_USED(opline)) {
21406                                         PZVAL_LOCK(z);
21407                                         EX_T(opline->result.var).var.ptr = z;
21408                                 }
21409                                 zval_ptr_dtor(&z);
21410                         } else {
21411                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
21412                                 if (RETURN_VALUE_USED(opline)) {
21413                                         PZVAL_LOCK(&EG(uninitialized_zval));
21414                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21415                                 }
21416                         }
21417                         zval_ptr_dtor(&object);
21418                 }
21419 
21420                 if (0) {
21421                         zval_ptr_dtor(&property);
21422                 } else {
21423 
21424                 }
21425                 FREE_OP(free_op_data1);
21426         }
21427 
21428         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21429         /* assign_obj has two opcodes! */
21430         CHECK_EXCEPTION();
21431         ZEND_VM_INC_OPCODE();
21432         ZEND_VM_NEXT_OPCODE();
21433 }
21434 
21435 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
21436 {
21437         USE_OPLINE
21438         zend_free_op free_op1, free_op_data2, free_op_data1;
21439         zval **var_ptr;
21440         zval *value;
21441 
21442         SAVE_OPLINE();
21443         switch (opline->extended_value) {
21444                 case ZEND_ASSIGN_OBJ:
21445                         return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21446                         break;
21447                 case ZEND_ASSIGN_DIM: {
21448                                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21449 
21450                                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
21451                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21452                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
21453                                         if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
21454                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
21455                                         }
21456                                         return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21457                                 } else {
21458                                         zval *dim = NULL;
21459 
21460                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
21461                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
21462                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
21463                                 }
21464                         }
21465                         break;
21466                 default:
21467                         value = NULL;
21468                         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21469                         /* do nothing */
21470                         break;
21471         }
21472 
21473         if (UNEXPECTED(var_ptr == NULL)) {
21474                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
21475         }
21476 
21477         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
21478                 if (RETURN_VALUE_USED(opline)) {
21479                         PZVAL_LOCK(&EG(uninitialized_zval));
21480                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21481                 }
21482 
21483                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21484                 CHECK_EXCEPTION();
21485                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
21486                         ZEND_VM_INC_OPCODE();
21487                 }
21488                 ZEND_VM_NEXT_OPCODE();
21489         }
21490 
21491         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
21492 
21493         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
21494            && Z_OBJ_HANDLER_PP(var_ptr, get)
21495            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
21496                 /* proxy object */
21497                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
21498                 Z_ADDREF_P(objval);
21499                 binary_op(objval, objval, value TSRMLS_CC);
21500                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
21501                 zval_ptr_dtor(&objval);
21502         } else {
21503                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
21504         }
21505 
21506         if (RETURN_VALUE_USED(opline)) {
21507                 PZVAL_LOCK(*var_ptr);
21508                 EX_T(opline->result.var).var.ptr = *var_ptr;
21509         }
21510 
21511         if (opline->extended_value == ZEND_ASSIGN_DIM) {
21512                 FREE_OP(free_op_data1);
21513                 FREE_OP_VAR_PTR(free_op_data2);
21514                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21515                 CHECK_EXCEPTION();
21516                 ZEND_VM_INC_OPCODE();
21517         } else {
21518                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21519                 CHECK_EXCEPTION();
21520         }
21521         ZEND_VM_NEXT_OPCODE();
21522 }
21523 
21524 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21525 {
21526         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21527 }
21528 
21529 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21530 {
21531         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21532 }
21533 
21534 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21535 {
21536         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21537 }
21538 
21539 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21540 {
21541         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21542 }
21543 
21544 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21545 {
21546         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21547 }
21548 
21549 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21550 {
21551         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21552 }
21553 
21554 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21555 {
21556         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21557 }
21558 
21559 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21560 {
21561         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21562 }
21563 
21564 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21565 {
21566         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21567 }
21568 
21569 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21570 {
21571         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21572 }
21573 
21574 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21575 {
21576         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21577 }
21578 
21579 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
21580 {
21581         USE_OPLINE
21582         zend_free_op free_op1;
21583         zval *varname;
21584         zval **retval;
21585         zval tmp_varname;
21586         HashTable *target_symbol_table;
21587         ulong hash_value;
21588 
21589         SAVE_OPLINE();
21590         varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21591 
21592         if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
21593                 ZVAL_COPY_VALUE(&tmp_varname, varname);
21594                 zval_copy_ctor(&tmp_varname);
21595                 Z_SET_REFCOUNT(tmp_varname, 1);
21596                 Z_UNSET_ISREF(tmp_varname);
21597                 convert_to_string(&tmp_varname);
21598                 varname = &tmp_varname;
21599         }
21600 
21601         if (IS_UNUSED != IS_UNUSED) {
21602                 zend_class_entry *ce;
21603 
21604                 if (IS_UNUSED == IS_CONST) {
21605                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
21606                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
21607                         } else {
21608                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
21609                                 if (UNEXPECTED(ce == NULL)) {
21610                                         if (IS_VAR != IS_CONST && varname == &tmp_varname) {
21611                                                 zval_dtor(&tmp_varname);
21612                                         }
21613                                         zval_ptr_dtor_nogc(&free_op1.var);
21614                                         CHECK_EXCEPTION();
21615                                         ZEND_VM_NEXT_OPCODE();
21616                                 }
21617                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
21618                         }
21619                 } else {
21620                         ce = EX_T(opline->op2.var).class_entry;
21621                 }
21622                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
21623                 zval_ptr_dtor_nogc(&free_op1.var);
21624         } else {
21625                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
21626 /*
21627                 if (!target_symbol_table) {
21628                         CHECK_EXCEPTION();
21629                         ZEND_VM_NEXT_OPCODE();
21630                 }
21631 */
21632                 if (IS_VAR == IS_CONST) {
21633                         hash_value = Z_HASH_P(varname);
21634                 } else {
21635                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
21636                 }
21637 
21638                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
21639                         switch (type) {
21640                                 case BP_VAR_R:
21641                                 case BP_VAR_UNSET:
21642                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
21643                                         /* break missing intentionally */
21644                                 case BP_VAR_IS:
21645                                         retval = &EG(uninitialized_zval_ptr);
21646                                         break;
21647                                 case BP_VAR_RW:
21648                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
21649                                         /* break missing intentionally */
21650                                 case BP_VAR_W:
21651                                         Z_ADDREF_P(&EG(uninitialized_zval));
21652                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
21653                                         break;
21654                                 EMPTY_SWITCH_DEFAULT_CASE()
21655                         }
21656                 }
21657                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
21658                         case ZEND_FETCH_GLOBAL:
21659                                 if (IS_VAR != IS_TMP_VAR) {
21660                                         zval_ptr_dtor_nogc(&free_op1.var);
21661                                 }
21662                                 break;
21663                         case ZEND_FETCH_LOCAL:
21664                                 zval_ptr_dtor_nogc(&free_op1.var);
21665                                 break;
21666                         case ZEND_FETCH_STATIC:
21667                                 zval_update_constant(retval, 1 TSRMLS_CC);
21668                                 break;
21669                         case ZEND_FETCH_GLOBAL_LOCK:
21670                                 if (IS_VAR == IS_VAR && !free_op1.var) {
21671                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
21672                                 }
21673                                 break;
21674                 }
21675         }
21676 
21677 
21678         if (IS_VAR != IS_CONST && varname == &tmp_varname) {
21679                 zval_dtor(&tmp_varname);
21680         }
21681         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
21682                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
21683         }
21684         PZVAL_LOCK(*retval);
21685         switch (type) {
21686                 case BP_VAR_R:
21687                 case BP_VAR_IS:
21688                         EX_T(opline->result.var).var.ptr = *retval;
21689                         break;
21690                 case BP_VAR_UNSET: {
21691                         zend_free_op free_res;
21692 
21693                         PZVAL_UNLOCK(*retval, &free_res);
21694                         if (retval != &EG(uninitialized_zval_ptr)) {
21695                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
21696                         }
21697                         PZVAL_LOCK(*retval);
21698                         FREE_OP_VAR_PTR(free_res);
21699                 }
21700                 /* break missing intentionally */
21701                 default:
21702                         EX_T(opline->result.var).var.ptr_ptr = retval;
21703                         break;
21704         }
21705         CHECK_EXCEPTION();
21706         ZEND_VM_NEXT_OPCODE();
21707 }
21708 
21709 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21710 {
21711         return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21712 }
21713 
21714 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21715 {
21716         return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21717 }
21718 
21719 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21720 {
21721         return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21722 }
21723 
21724 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21725 {
21726         USE_OPLINE
21727 
21728         return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21729 }
21730 
21731 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21732 {
21733         return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21734 }
21735 
21736 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21737 {
21738         return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
21739 }
21740 
21741 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21742 {
21743         USE_OPLINE
21744         zend_free_op free_op1;
21745         zval **container;
21746 
21747         SAVE_OPLINE();
21748         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21749 
21750         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
21751                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21752         }
21753         zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
21754 
21755         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
21756                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
21757         }
21758         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21759 
21760         /* We are going to assign the result by reference */
21761         if (UNEXPECTED(opline->extended_value != 0)) {
21762                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
21763 
21764                 if (retval_ptr) {
21765                         Z_DELREF_PP(retval_ptr);
21766                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
21767                         Z_ADDREF_PP(retval_ptr);
21768                 }
21769         }
21770 
21771         CHECK_EXCEPTION();
21772         ZEND_VM_NEXT_OPCODE();
21773 }
21774 
21775 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21776 {
21777         USE_OPLINE
21778         zend_free_op free_op1;
21779         zval **container;
21780 
21781         SAVE_OPLINE();
21782         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21783 
21784         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
21785                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21786         }
21787         zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
21788 
21789         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
21790                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
21791         }
21792         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21793         CHECK_EXCEPTION();
21794         ZEND_VM_NEXT_OPCODE();
21795 }
21796 
21797 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21798 {
21799         USE_OPLINE
21800         zend_free_op free_op1;
21801 
21802         SAVE_OPLINE();
21803 
21804         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
21805                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21806                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
21807                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21808                 }
21809                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
21810                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
21811                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
21812                 }
21813 
21814                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21815         } else {
21816                 zval *container;
21817 
21818                 if (IS_UNUSED == IS_UNUSED) {
21819                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
21820                 }
21821                 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21822                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
21823 
21824                 zval_ptr_dtor_nogc(&free_op1.var);
21825         }
21826         CHECK_EXCEPTION();
21827         ZEND_VM_NEXT_OPCODE();
21828 }
21829 
21830 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21831 {
21832         USE_OPLINE
21833         zend_free_op free_op1;
21834         zval **object_ptr;
21835 
21836         SAVE_OPLINE();
21837         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
21838 
21839         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
21840                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
21841         }
21842         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
21843 
21844                 zval *property_name = NULL;
21845 
21846                 if (0) {
21847                         MAKE_REAL_ZVAL_PTR(property_name);
21848                 }
21849                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
21850                 if (0) {
21851                         zval_ptr_dtor(&property_name);
21852                 } else {
21853 
21854                 }
21855         } else {
21856                 zend_free_op free_op_data1, free_op_data2;
21857                 zval *value;
21858                 zval *dim = NULL;
21859                 zval **variable_ptr_ptr;
21860 
21861                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC);
21862 
21863                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
21864                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
21865                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
21866                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
21867                                 if (RETURN_VALUE_USED(opline)) {
21868                                         zval *retval;
21869 
21870                                         ALLOC_ZVAL(retval);
21871                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
21872                                         INIT_PZVAL(retval);
21873                                         EX_T(opline->result.var).var.ptr = retval;
21874                                 }
21875                         } else if (RETURN_VALUE_USED(opline)) {
21876                                 PZVAL_LOCK(&EG(uninitialized_zval));
21877                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21878                         }
21879                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
21880                         if (IS_TMP_FREE(free_op_data1)) {
21881                                 zval_dtor(value);
21882                         }
21883                         if (RETURN_VALUE_USED(opline)) {
21884                                 PZVAL_LOCK(&EG(uninitialized_zval));
21885                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
21886                         }
21887                 } else {
21888                         if ((opline+1)->op1_type == IS_TMP_VAR) {
21889                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
21890                         } else if ((opline+1)->op1_type == IS_CONST) {
21891                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
21892                         } else {
21893                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
21894                         }
21895                         if (RETURN_VALUE_USED(opline)) {
21896                                 PZVAL_LOCK(value);
21897                                 EX_T(opline->result.var).var.ptr = value;
21898                         }
21899                 }
21900                 FREE_OP_VAR_PTR(free_op_data2);
21901                 FREE_OP_IF_VAR(free_op_data1);
21902         }
21903         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
21904         /* assign_dim has two opcodes! */
21905         CHECK_EXCEPTION();
21906         ZEND_VM_INC_OPCODE();
21907         ZEND_VM_NEXT_OPCODE();
21908 }
21909 
21910 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21911 {
21912         USE_OPLINE
21913         zval *function_name;
21914         zend_class_entry *ce;
21915         call_slot *call = EX(call_slots) + opline->result.num;
21916 
21917         SAVE_OPLINE();
21918 
21919         if (IS_VAR == IS_CONST) {
21920                 /* no function found. try a static method in class */
21921                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
21922                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
21923                 } else {
21924                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
21925                         if (UNEXPECTED(EG(exception) != NULL)) {
21926                                 HANDLE_EXCEPTION();
21927                         }
21928                         if (UNEXPECTED(ce == NULL)) {
21929                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
21930                         }
21931                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
21932                 }
21933                 call->called_scope = ce;
21934         } else {
21935                 ce = EX_T(opline->op1.var).class_entry;
21936 
21937                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
21938                         call->called_scope = EG(called_scope);
21939                 } else {
21940                         call->called_scope = ce;
21941                 }
21942         }
21943 
21944         if (IS_VAR == IS_CONST &&
21945             IS_UNUSED == IS_CONST &&
21946             CACHED_PTR(opline->op2.literal->cache_slot)) {
21947                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
21948         } else if (IS_VAR != IS_CONST &&
21949                    IS_UNUSED == IS_CONST &&
21950                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
21951                 /* do nothing */
21952         } else if (IS_UNUSED != IS_UNUSED) {
21953                 char *function_name_strval = NULL;
21954                 int function_name_strlen = 0;
21955 
21956 
21957                 if (IS_UNUSED == IS_CONST) {
21958                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
21959                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
21960                 } else {
21961                         function_name = NULL;
21962 
21963                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
21964                                 if (UNEXPECTED(EG(exception) != NULL)) {
21965                                         HANDLE_EXCEPTION();
21966                                 }
21967                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
21968                         } else {
21969                                 function_name_strval = Z_STRVAL_P(function_name);
21970                                 function_name_strlen = Z_STRLEN_P(function_name);
21971                         }
21972                 }
21973 
21974                 if (function_name_strval) {
21975                         if (ce->get_static_method) {
21976                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
21977                         } else {
21978                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
21979                         }
21980                         if (UNEXPECTED(call->fbc == NULL)) {
21981                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
21982                         }
21983                         if (IS_UNUSED == IS_CONST &&
21984                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
21985                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
21986                                 if (IS_VAR == IS_CONST) {
21987                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
21988                                 } else {
21989                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
21990                                 }
21991                         }
21992                 }
21993                 if (IS_UNUSED != IS_CONST) {
21994 
21995                 }
21996         } else {
21997                 if (UNEXPECTED(ce->constructor == NULL)) {
21998                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
21999                 }
22000                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
22001                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
22002                 }
22003                 call->fbc = ce->constructor;
22004         }
22005 
22006         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
22007                 call->object = NULL;
22008         } else {
22009                 if (EG(This) &&
22010                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
22011                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
22012                     /* We are calling method of the other (incompatible) class,
22013                        but passing $this. This is done for compatibility with php-4. */
22014                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
22015                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
22016                         } else {
22017                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
22018                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
22019                         }
22020                 }
22021                 if ((call->object = EG(This))) {
22022                         Z_ADDREF_P(call->object);
22023                         call->called_scope = Z_OBJCE_P(call->object);
22024                 }
22025         }
22026 
22027         call->num_additional_args = 0;
22028         call->is_ctor_call = 0;
22029         EX(call) = call;
22030 
22031         CHECK_EXCEPTION();
22032         ZEND_VM_NEXT_OPCODE();
22033 }
22034 
22035 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22036 {
22037         USE_OPLINE
22038         zend_free_op free_op1;
22039         zval *expr_ptr;
22040 
22041         SAVE_OPLINE();
22042         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
22043                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22044 
22045                 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
22046                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
22047                 }
22048                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
22049                 expr_ptr = *expr_ptr_ptr;
22050                 Z_ADDREF_P(expr_ptr);
22051         } else {
22052                 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22053                 if (0) { /* temporary variable */
22054                         zval *new_expr;
22055 
22056                         ALLOC_ZVAL(new_expr);
22057                         INIT_PZVAL_COPY(new_expr, expr_ptr);
22058                         expr_ptr = new_expr;
22059                 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
22060                         zval *new_expr;
22061 
22062                         ALLOC_ZVAL(new_expr);
22063                         INIT_PZVAL_COPY(new_expr, expr_ptr);
22064                         expr_ptr = new_expr;
22065                         zendi_zval_copy_ctor(*expr_ptr);
22066                         zval_ptr_dtor_nogc(&free_op1.var);
22067                 } else if (IS_VAR == IS_CV) {
22068                         Z_ADDREF_P(expr_ptr);
22069                 }
22070         }
22071 
22072         if (IS_UNUSED != IS_UNUSED) {
22073 
22074                 zval *offset = NULL;
22075                 ulong hval;
22076 
22077                 switch (Z_TYPE_P(offset)) {
22078                         case IS_DOUBLE:
22079                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
22080                                 goto num_index;
22081                         case IS_LONG:
22082                         case IS_BOOL:
22083                                 hval = Z_LVAL_P(offset);
22084 num_index:
22085                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
22086                                 break;
22087                         case IS_STRING:
22088                                 if (IS_UNUSED == IS_CONST) {
22089                                         hval = Z_HASH_P(offset);
22090                                 } else {
22091                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
22092                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
22093                                 }
22094                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
22095                                 break;
22096                         case IS_NULL:
22097                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
22098                                 break;
22099                         default:
22100                                 zend_error(E_WARNING, "Illegal offset type");
22101                                 zval_ptr_dtor(&expr_ptr);
22102                                 /* do nothing */
22103                                 break;
22104                 }
22105 
22106         } else {
22107                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
22108         }
22109         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
22110                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22111         }
22112         CHECK_EXCEPTION();
22113         ZEND_VM_NEXT_OPCODE();
22114 }
22115 
22116 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22117 {
22118         USE_OPLINE
22119 
22120         array_init(&EX_T(opline->result.var).tmp_var);
22121         if (IS_VAR == IS_UNUSED) {
22122                 ZEND_VM_NEXT_OPCODE();
22123 #if 0 || IS_VAR != IS_UNUSED
22124         } else {
22125                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22126 #endif
22127         }
22128 }
22129 
22130 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22131 {
22132         USE_OPLINE
22133         zval tmp, *varname;
22134         HashTable *target_symbol_table;
22135         zend_free_op free_op1;
22136 
22137         SAVE_OPLINE();
22138         if (IS_VAR == IS_CV &&
22139             IS_UNUSED == IS_UNUSED &&
22140             (opline->extended_value & ZEND_QUICK_SET)) {
22141                 if (EG(active_symbol_table)) {
22142                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
22143 
22144                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
22145                         EX_CV(opline->op1.var) = NULL;
22146                 } else if (EX_CV(opline->op1.var)) {
22147                         zval_ptr_dtor(EX_CV(opline->op1.var));
22148                         EX_CV(opline->op1.var) = NULL;
22149                 }
22150                 CHECK_EXCEPTION();
22151                 ZEND_VM_NEXT_OPCODE();
22152         }
22153 
22154         varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22155 
22156         if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
22157                 ZVAL_COPY_VALUE(&tmp, varname);
22158                 zval_copy_ctor(&tmp);
22159                 convert_to_string(&tmp);
22160                 varname = &tmp;
22161         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22162                 Z_ADDREF_P(varname);
22163         }
22164 
22165         if (IS_UNUSED != IS_UNUSED) {
22166                 zend_class_entry *ce;
22167 
22168                 if (IS_UNUSED == IS_CONST) {
22169                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
22170                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
22171                         } else {
22172                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
22173                                 if (UNEXPECTED(EG(exception) != NULL)) {
22174                                         if (IS_VAR != IS_CONST && varname == &tmp) {
22175                                                 zval_dtor(&tmp);
22176                                         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22177                                                 zval_ptr_dtor(&varname);
22178                                         }
22179                                         zval_ptr_dtor_nogc(&free_op1.var);
22180                                         HANDLE_EXCEPTION();
22181                                 }
22182                                 if (UNEXPECTED(ce == NULL)) {
22183                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
22184                                 }
22185                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
22186                         }
22187                 } else {
22188                         ce = EX_T(opline->op2.var).class_entry;
22189                 }
22190                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
22191         } else {
22192                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
22193 
22194                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
22195                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
22196         }
22197 
22198         if (IS_VAR != IS_CONST && varname == &tmp) {
22199                 zval_dtor(&tmp);
22200         } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22201                 zval_ptr_dtor(&varname);
22202         }
22203         zval_ptr_dtor_nogc(&free_op1.var);
22204         CHECK_EXCEPTION();
22205         ZEND_VM_NEXT_OPCODE();
22206 }
22207 
22208 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22209 {
22210         USE_OPLINE
22211         zval **value;
22212         zend_bool isset = 1;
22213 
22214         SAVE_OPLINE();
22215         if (IS_VAR == IS_CV &&
22216             IS_UNUSED == IS_UNUSED &&
22217             (opline->extended_value & ZEND_QUICK_SET)) {
22218                 if (EX_CV(opline->op1.var)) {
22219                         value = EX_CV(opline->op1.var);
22220                 } else if (EG(active_symbol_table)) {
22221                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
22222 
22223                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
22224                                 isset = 0;
22225                         }
22226                 } else {
22227                         isset = 0;
22228                 }
22229         } else {
22230                 HashTable *target_symbol_table;
22231                 zend_free_op free_op1;
22232                 zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22233 
22234                 if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
22235                         ZVAL_COPY_VALUE(&tmp, varname);
22236                         zval_copy_ctor(&tmp);
22237                         convert_to_string(&tmp);
22238                         varname = &tmp;
22239                 }
22240 
22241                 if (IS_UNUSED != IS_UNUSED) {
22242                         zend_class_entry *ce;
22243 
22244                         if (IS_UNUSED == IS_CONST) {
22245                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
22246                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
22247                                 } else {
22248                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
22249                                         if (UNEXPECTED(ce == NULL)) {
22250                                                 CHECK_EXCEPTION();
22251                                                 ZEND_VM_NEXT_OPCODE();
22252                                         }
22253                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
22254                                 }
22255                         } else {
22256                                 ce = EX_T(opline->op2.var).class_entry;
22257                         }
22258                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
22259                         if (!value) {
22260                                 isset = 0;
22261                         }
22262                 } else {
22263                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
22264                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
22265                                 isset = 0;
22266                         }
22267                 }
22268 
22269                 if (IS_VAR != IS_CONST && varname == &tmp) {
22270                         zval_dtor(&tmp);
22271                 }
22272                 zval_ptr_dtor_nogc(&free_op1.var);
22273         }
22274 
22275         if (opline->extended_value & ZEND_ISSET) {
22276                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
22277                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
22278                 } else {
22279                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
22280                 }
22281         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
22282                 if (!isset || !i_zend_is_true(*value)) {
22283                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
22284                 } else {
22285                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
22286                 }
22287         }
22288 
22289         CHECK_EXCEPTION();
22290         ZEND_VM_NEXT_OPCODE();
22291 }
22292 
22293 static int ZEND_FASTCALL  ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22294 {
22295         USE_OPLINE
22296         zval *var_ptr, *new_zv;
22297 
22298         SAVE_OPLINE();
22299         var_ptr = EX_T(opline->op1.var).var.ptr;
22300         if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
22301                         !PZVAL_IS_REF(var_ptr) &&
22302                         Z_REFCOUNT_P(var_ptr) > 1) {
22303 
22304                 Z_DELREF_P(var_ptr);
22305                 ALLOC_ZVAL(new_zv);
22306                 INIT_PZVAL_COPY(new_zv, var_ptr);
22307                 var_ptr = new_zv;
22308                 zval_copy_ctor(var_ptr);
22309                 EX_T(opline->op1.var).var.ptr = var_ptr;
22310         }
22311         ZEND_VM_NEXT_OPCODE();
22312 }
22313 
22314 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22315 {
22316         USE_OPLINE
22317 
22318         /* The generator object is stored in return_value_ptr_ptr */
22319         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
22320 
22321         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
22322                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
22323         }
22324 
22325         /* Destroy the previously yielded value */
22326         if (generator->value) {
22327                 zval_ptr_dtor(&generator->value);
22328         }
22329 
22330         /* Destroy the previously yielded key */
22331         if (generator->key) {
22332                 zval_ptr_dtor(&generator->key);
22333         }
22334 
22335         /* Set the new yielded value */
22336         if (IS_VAR != IS_UNUSED) {
22337                 zend_free_op free_op1;
22338 
22339                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
22340                         /* Constants and temporary variables aren't yieldable by reference,
22341                          * but we still allow them with a notice. */
22342                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
22343                                 zval *value, *copy;
22344 
22345                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22346 
22347                                 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22348                                 ALLOC_ZVAL(copy);
22349                                 INIT_PZVAL_COPY(copy, value);
22350 
22351                                 /* Temporary variables don't need ctor copying */
22352                                 if (!0) {
22353                                         zval_copy_ctor(copy);
22354                                 }
22355 
22356                                 generator->value = copy;
22357                         } else {
22358                                 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22359 
22360                                 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
22361                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
22362                                 }
22363 
22364                                 /* If a function call result is yielded and the function did
22365                                  * not return by reference we throw a notice. */
22366                                 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
22367                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
22368                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
22369                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
22370                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22371 
22372                                         Z_ADDREF_PP(value_ptr);
22373                                         generator->value = *value_ptr;
22374                                 } else {
22375                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
22376                                         Z_ADDREF_PP(value_ptr);
22377                                         generator->value = *value_ptr;
22378                                 }
22379 
22380                                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22381                         }
22382                 } else {
22383                         zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22384 
22385                         /* Consts, temporary variables and references need copying */
22386                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
22387                                 || PZVAL_IS_REF(value)
22388                         ) {
22389                                 zval *copy;
22390 
22391                                 ALLOC_ZVAL(copy);
22392                                 INIT_PZVAL_COPY(copy, value);
22393 
22394                                 /* Temporary variables don't need ctor copying */
22395                                 if (!0) {
22396                                         zval_copy_ctor(copy);
22397                                 }
22398 
22399                                 generator->value = copy;
22400                                 zval_ptr_dtor_nogc(&free_op1.var);
22401                         } else {
22402                                 if (IS_VAR == IS_CV) {
22403                                         Z_ADDREF_P(value);
22404                                 }
22405                                 generator->value = value;
22406                         }
22407                 }
22408         } else {
22409                 /* If no value was specified yield null */
22410                 Z_ADDREF(EG(uninitialized_zval));
22411                 generator->value = &EG(uninitialized_zval);
22412         }
22413 
22414         /* Set the new yielded key */
22415         if (IS_UNUSED != IS_UNUSED) {
22416 
22417                 zval *key = NULL;
22418 
22419                 /* Consts, temporary variables and references need copying */
22420                 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
22421                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
22422                 ) {
22423                         zval *copy;
22424 
22425                         ALLOC_ZVAL(copy);
22426                         INIT_PZVAL_COPY(copy, key);
22427 
22428                         /* Temporary variables don't need ctor copying */
22429                         if (!0) {
22430                                 zval_copy_ctor(copy);
22431                         }
22432 
22433                         generator->key = copy;
22434                 } else {
22435                         Z_ADDREF_P(key);
22436                         generator->key = key;
22437                 }
22438 
22439                 if (Z_TYPE_P(generator->key) == IS_LONG
22440                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
22441                 ) {
22442                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
22443                 }
22444 
22445         } else {
22446                 /* If no key was specified we use auto-increment keys */
22447                 generator->largest_used_integer_key++;
22448 
22449                 ALLOC_INIT_ZVAL(generator->key);
22450                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
22451         }
22452 
22453         if (RETURN_VALUE_USED(opline)) {
22454                 /* If the return value of yield is used set the send
22455                  * target and initialize it to NULL */
22456                 generator->send_target = &EX_T(opline->result.var).var.ptr;
22457                 Z_ADDREF(EG(uninitialized_zval));
22458                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
22459         } else {
22460                 generator->send_target = NULL;
22461         }
22462 
22463         /* We increment to the next op, so we are at the correct position when the
22464          * generator is resumed. */
22465         ZEND_VM_INC_OPCODE();
22466 
22467         /* The GOTO VM uses a local opline variable. We need to set the opline
22468          * variable in execute_data so we don't resume at an old position. */
22469         SAVE_OPLINE();
22470 
22471         ZEND_VM_RETURN();
22472 }
22473 
22474 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22475 {
22476         return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22477 }
22478 
22479 static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22480 {
22481         USE_OPLINE
22482         zend_free_op free_op1;
22483 
22484         SAVE_OPLINE();
22485         fast_add_function(&EX_T(opline->result.var).tmp_var,
22486                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22487                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22488         zval_ptr_dtor_nogc(&free_op1.var);
22489 
22490         CHECK_EXCEPTION();
22491         ZEND_VM_NEXT_OPCODE();
22492 }
22493 
22494 static int ZEND_FASTCALL  ZEND_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22495 {
22496         USE_OPLINE
22497         zend_free_op free_op1;
22498 
22499         SAVE_OPLINE();
22500         fast_sub_function(&EX_T(opline->result.var).tmp_var,
22501                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22502                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22503         zval_ptr_dtor_nogc(&free_op1.var);
22504 
22505         CHECK_EXCEPTION();
22506         ZEND_VM_NEXT_OPCODE();
22507 }
22508 
22509 static int ZEND_FASTCALL  ZEND_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22510 {
22511         USE_OPLINE
22512         zend_free_op free_op1;
22513 
22514         SAVE_OPLINE();
22515         fast_mul_function(&EX_T(opline->result.var).tmp_var,
22516                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22517                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22518         zval_ptr_dtor_nogc(&free_op1.var);
22519 
22520         CHECK_EXCEPTION();
22521         ZEND_VM_NEXT_OPCODE();
22522 }
22523 
22524 static int ZEND_FASTCALL  ZEND_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22525 {
22526         USE_OPLINE
22527         zend_free_op free_op1;
22528 
22529         SAVE_OPLINE();
22530         fast_div_function(&EX_T(opline->result.var).tmp_var,
22531                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22532                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22533         zval_ptr_dtor_nogc(&free_op1.var);
22534 
22535         CHECK_EXCEPTION();
22536         ZEND_VM_NEXT_OPCODE();
22537 }
22538 
22539 static int ZEND_FASTCALL  ZEND_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22540 {
22541         USE_OPLINE
22542         zend_free_op free_op1;
22543 
22544         SAVE_OPLINE();
22545         fast_mod_function(&EX_T(opline->result.var).tmp_var,
22546                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22547                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22548         zval_ptr_dtor_nogc(&free_op1.var);
22549 
22550         CHECK_EXCEPTION();
22551         ZEND_VM_NEXT_OPCODE();
22552 }
22553 
22554 static int ZEND_FASTCALL  ZEND_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22555 {
22556         USE_OPLINE
22557         zend_free_op free_op1;
22558 
22559         SAVE_OPLINE();
22560         shift_left_function(&EX_T(opline->result.var).tmp_var,
22561                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22562                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22563         zval_ptr_dtor_nogc(&free_op1.var);
22564 
22565         CHECK_EXCEPTION();
22566         ZEND_VM_NEXT_OPCODE();
22567 }
22568 
22569 static int ZEND_FASTCALL  ZEND_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22570 {
22571         USE_OPLINE
22572         zend_free_op free_op1;
22573 
22574         SAVE_OPLINE();
22575         shift_right_function(&EX_T(opline->result.var).tmp_var,
22576                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22577                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22578         zval_ptr_dtor_nogc(&free_op1.var);
22579 
22580         CHECK_EXCEPTION();
22581         ZEND_VM_NEXT_OPCODE();
22582 }
22583 
22584 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22585 {
22586         USE_OPLINE
22587         zend_free_op free_op1;
22588 
22589         SAVE_OPLINE();
22590         concat_function(&EX_T(opline->result.var).tmp_var,
22591                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22592                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22593         zval_ptr_dtor_nogc(&free_op1.var);
22594 
22595         CHECK_EXCEPTION();
22596         ZEND_VM_NEXT_OPCODE();
22597 }
22598 
22599 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22600 {
22601         USE_OPLINE
22602         zend_free_op free_op1;
22603 
22604         SAVE_OPLINE();
22605         is_identical_function(&EX_T(opline->result.var).tmp_var,
22606                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22607                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22608         zval_ptr_dtor_nogc(&free_op1.var);
22609 
22610         CHECK_EXCEPTION();
22611         ZEND_VM_NEXT_OPCODE();
22612 }
22613 
22614 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22615 {
22616         USE_OPLINE
22617         zend_free_op free_op1;
22618         zval *result = &EX_T(opline->result.var).tmp_var;
22619 
22620         SAVE_OPLINE();
22621         is_identical_function(result,
22622                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22623                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22624         Z_LVAL_P(result) = !Z_LVAL_P(result);
22625         zval_ptr_dtor_nogc(&free_op1.var);
22626 
22627         CHECK_EXCEPTION();
22628         ZEND_VM_NEXT_OPCODE();
22629 }
22630 
22631 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22632 {
22633         USE_OPLINE
22634         zend_free_op free_op1;
22635         zval *result = &EX_T(opline->result.var).tmp_var;
22636 
22637         SAVE_OPLINE();
22638         ZVAL_BOOL(result, fast_equal_function(result,
22639                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22640                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
22641         zval_ptr_dtor_nogc(&free_op1.var);
22642 
22643         CHECK_EXCEPTION();
22644         ZEND_VM_NEXT_OPCODE();
22645 }
22646 
22647 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22648 {
22649         USE_OPLINE
22650         zend_free_op free_op1;
22651         zval *result = &EX_T(opline->result.var).tmp_var;
22652 
22653         SAVE_OPLINE();
22654         ZVAL_BOOL(result, fast_not_equal_function(result,
22655                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22656                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
22657         zval_ptr_dtor_nogc(&free_op1.var);
22658 
22659         CHECK_EXCEPTION();
22660         ZEND_VM_NEXT_OPCODE();
22661 }
22662 
22663 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22664 {
22665         USE_OPLINE
22666         zend_free_op free_op1;
22667         zval *result = &EX_T(opline->result.var).tmp_var;
22668 
22669         SAVE_OPLINE();
22670         ZVAL_BOOL(result, fast_is_smaller_function(result,
22671                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22672                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
22673         zval_ptr_dtor_nogc(&free_op1.var);
22674 
22675         CHECK_EXCEPTION();
22676         ZEND_VM_NEXT_OPCODE();
22677 }
22678 
22679 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22680 {
22681         USE_OPLINE
22682         zend_free_op free_op1;
22683         zval *result = &EX_T(opline->result.var).tmp_var;
22684 
22685         SAVE_OPLINE();
22686         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
22687                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22688                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
22689         zval_ptr_dtor_nogc(&free_op1.var);
22690 
22691         CHECK_EXCEPTION();
22692         ZEND_VM_NEXT_OPCODE();
22693 }
22694 
22695 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22696 {
22697         USE_OPLINE
22698         zend_free_op free_op1;
22699 
22700         SAVE_OPLINE();
22701         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
22702                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22703                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22704         zval_ptr_dtor_nogc(&free_op1.var);
22705 
22706         CHECK_EXCEPTION();
22707         ZEND_VM_NEXT_OPCODE();
22708 }
22709 
22710 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22711 {
22712         USE_OPLINE
22713         zend_free_op free_op1;
22714 
22715         SAVE_OPLINE();
22716         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
22717                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22718                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22719         zval_ptr_dtor_nogc(&free_op1.var);
22720 
22721         CHECK_EXCEPTION();
22722         ZEND_VM_NEXT_OPCODE();
22723 }
22724 
22725 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22726 {
22727         USE_OPLINE
22728         zend_free_op free_op1;
22729 
22730         SAVE_OPLINE();
22731         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
22732                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22733                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22734         zval_ptr_dtor_nogc(&free_op1.var);
22735 
22736         CHECK_EXCEPTION();
22737         ZEND_VM_NEXT_OPCODE();
22738 }
22739 
22740 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22741 {
22742         USE_OPLINE
22743         zend_free_op free_op1;
22744 
22745         SAVE_OPLINE();
22746         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
22747                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
22748                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
22749         zval_ptr_dtor_nogc(&free_op1.var);
22750 
22751         CHECK_EXCEPTION();
22752         ZEND_VM_NEXT_OPCODE();
22753 }
22754 
22755 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
22756 {
22757         USE_OPLINE
22758         zend_free_op free_op1, free_op_data1;
22759         zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22760         zval *object;
22761         zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
22762         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
22763         int have_get_ptr = 0;
22764 
22765         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
22766                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
22767         }
22768 
22769         make_real_object(object_ptr TSRMLS_CC);
22770         object = *object_ptr;
22771 
22772         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
22773                 zend_error(E_WARNING, "Attempt to assign property of non-object");
22774 
22775                 FREE_OP(free_op_data1);
22776 
22777                 if (RETURN_VALUE_USED(opline)) {
22778                         PZVAL_LOCK(&EG(uninitialized_zval));
22779                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
22780                 }
22781         } else {
22782                 /* here we are sure we are dealing with an object */
22783                 if (0) {
22784                         MAKE_REAL_ZVAL_PTR(property);
22785                 }
22786 
22787                 /* here property is a string */
22788                 if (opline->extended_value == ZEND_ASSIGN_OBJ
22789                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
22790                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
22791                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
22792                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
22793 
22794                                 have_get_ptr = 1;
22795                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
22796                                 if (RETURN_VALUE_USED(opline)) {
22797                                         PZVAL_LOCK(*zptr);
22798                                         EX_T(opline->result.var).var.ptr = *zptr;
22799                                 }
22800                         }
22801                 }
22802 
22803                 if (!have_get_ptr) {
22804                         zval *z = NULL;
22805 
22806                         Z_ADDREF_P(object);
22807                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
22808                                 if (Z_OBJ_HT_P(object)->read_property) {
22809                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
22810                                 }
22811                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
22812                                 if (Z_OBJ_HT_P(object)->read_dimension) {
22813                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
22814                                 }
22815                         }
22816                         if (z) {
22817                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
22818                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
22819 
22820                                         if (Z_REFCOUNT_P(z) == 0) {
22821                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
22822                                                 zval_dtor(z);
22823                                                 FREE_ZVAL(z);
22824                                         }
22825                                         z = value;
22826                                 }
22827                                 Z_ADDREF_P(z);
22828                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
22829                                 binary_op(z, z, value TSRMLS_CC);
22830                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
22831                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
22832                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
22833                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
22834                                 }
22835                                 if (RETURN_VALUE_USED(opline)) {
22836                                         PZVAL_LOCK(z);
22837                                         EX_T(opline->result.var).var.ptr = z;
22838                                 }
22839                                 zval_ptr_dtor(&z);
22840                         } else {
22841                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
22842                                 if (RETURN_VALUE_USED(opline)) {
22843                                         PZVAL_LOCK(&EG(uninitialized_zval));
22844                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
22845                                 }
22846                         }
22847                         zval_ptr_dtor(&object);
22848                 }
22849 
22850                 if (0) {
22851                         zval_ptr_dtor(&property);
22852                 } else {
22853 
22854                 }
22855                 FREE_OP(free_op_data1);
22856         }
22857 
22858         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22859         /* assign_obj has two opcodes! */
22860         CHECK_EXCEPTION();
22861         ZEND_VM_INC_OPCODE();
22862         ZEND_VM_NEXT_OPCODE();
22863 }
22864 
22865 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
22866 {
22867         USE_OPLINE
22868         zend_free_op free_op1, free_op_data2, free_op_data1;
22869         zval **var_ptr;
22870         zval *value;
22871 
22872         SAVE_OPLINE();
22873         switch (opline->extended_value) {
22874                 case ZEND_ASSIGN_OBJ:
22875                         return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22876                         break;
22877                 case ZEND_ASSIGN_DIM: {
22878                                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22879 
22880                                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
22881                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
22882                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
22883                                         if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
22884                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
22885                                         }
22886                                         return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22887                                 } else {
22888                                         zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
22889 
22890                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
22891                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
22892                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
22893                                 }
22894                         }
22895                         break;
22896                 default:
22897                         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
22898                         var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
22899                         /* do nothing */
22900                         break;
22901         }
22902 
22903         if (UNEXPECTED(var_ptr == NULL)) {
22904                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
22905         }
22906 
22907         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
22908                 if (RETURN_VALUE_USED(opline)) {
22909                         PZVAL_LOCK(&EG(uninitialized_zval));
22910                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
22911                 }
22912 
22913                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22914                 CHECK_EXCEPTION();
22915                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
22916                         ZEND_VM_INC_OPCODE();
22917                 }
22918                 ZEND_VM_NEXT_OPCODE();
22919         }
22920 
22921         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
22922 
22923         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
22924            && Z_OBJ_HANDLER_PP(var_ptr, get)
22925            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
22926                 /* proxy object */
22927                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
22928                 Z_ADDREF_P(objval);
22929                 binary_op(objval, objval, value TSRMLS_CC);
22930                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
22931                 zval_ptr_dtor(&objval);
22932         } else {
22933                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
22934         }
22935 
22936         if (RETURN_VALUE_USED(opline)) {
22937                 PZVAL_LOCK(*var_ptr);
22938                 EX_T(opline->result.var).var.ptr = *var_ptr;
22939         }
22940 
22941         if (opline->extended_value == ZEND_ASSIGN_DIM) {
22942                 FREE_OP(free_op_data1);
22943                 FREE_OP_VAR_PTR(free_op_data2);
22944                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22945                 CHECK_EXCEPTION();
22946                 ZEND_VM_INC_OPCODE();
22947         } else {
22948                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
22949                 CHECK_EXCEPTION();
22950         }
22951         ZEND_VM_NEXT_OPCODE();
22952 }
22953 
22954 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22955 {
22956         return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22957 }
22958 
22959 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22960 {
22961         return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22962 }
22963 
22964 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22965 {
22966         return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22967 }
22968 
22969 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22970 {
22971         return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22972 }
22973 
22974 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22975 {
22976         return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22977 }
22978 
22979 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22980 {
22981         return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22982 }
22983 
22984 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22985 {
22986         return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22987 }
22988 
22989 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22990 {
22991         return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22992 }
22993 
22994 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22995 {
22996         return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
22997 }
22998 
22999 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23000 {
23001         return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23002 }
23003 
23004 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23005 {
23006         return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23007 }
23008 
23009 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
23010 {
23011         USE_OPLINE
23012         zend_free_op free_op1;
23013         zval **object_ptr;
23014         zval *object;
23015         zval *property;
23016         zval **retval;
23017         int have_get_ptr = 0;
23018 
23019         SAVE_OPLINE();
23020         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23021         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23022         retval = &EX_T(opline->result.var).var.ptr;
23023 
23024         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
23025                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
23026         }
23027 
23028         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
23029         object = *object_ptr;
23030 
23031         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23032                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23033 
23034                 if (RETURN_VALUE_USED(opline)) {
23035                         PZVAL_LOCK(&EG(uninitialized_zval));
23036                         *retval = &EG(uninitialized_zval);
23037                 }
23038                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23039                 CHECK_EXCEPTION();
23040                 ZEND_VM_NEXT_OPCODE();
23041         }
23042 
23043         /* here we are sure we are dealing with an object */
23044 
23045         if (0) {
23046                 MAKE_REAL_ZVAL_PTR(property);
23047         }
23048 
23049         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23050                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23051                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
23052                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
23053 
23054                         have_get_ptr = 1;
23055                         incdec_op(*zptr);
23056                         if (RETURN_VALUE_USED(opline)) {
23057                                 *retval = *zptr;
23058                                 PZVAL_LOCK(*retval);
23059                         }
23060                 }
23061         }
23062 
23063         if (!have_get_ptr) {
23064                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
23065                         zval *z;
23066 
23067                         Z_ADDREF_P(object);
23068                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23069 
23070                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
23071                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23072 
23073                                 if (Z_REFCOUNT_P(z) == 0) {
23074                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
23075                                         zval_dtor(z);
23076                                         FREE_ZVAL(z);
23077                                 }
23078                                 z = value;
23079                         }
23080                         Z_ADDREF_P(z);
23081                         SEPARATE_ZVAL_IF_NOT_REF(&z);
23082                         incdec_op(z);
23083                         *retval = z;
23084                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23085                         zval_ptr_dtor(&object);
23086                         SELECTIVE_PZVAL_LOCK(*retval, opline);
23087                         zval_ptr_dtor(&z);
23088                 } else {
23089                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23090                         if (RETURN_VALUE_USED(opline)) {
23091                                 PZVAL_LOCK(&EG(uninitialized_zval));
23092                                 *retval = &EG(uninitialized_zval);
23093                         }
23094                 }
23095         }
23096 
23097         if (0) {
23098                 zval_ptr_dtor(&property);
23099         } else {
23100 
23101         }
23102         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23103         CHECK_EXCEPTION();
23104         ZEND_VM_NEXT_OPCODE();
23105 }
23106 
23107 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23108 {
23109         return zend_pre_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23110 }
23111 
23112 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23113 {
23114         return zend_pre_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23115 }
23116 
23117 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
23118 {
23119         USE_OPLINE
23120         zend_free_op free_op1;
23121         zval **object_ptr;
23122         zval *object;
23123         zval *property;
23124         zval *retval;
23125         int have_get_ptr = 0;
23126 
23127         SAVE_OPLINE();
23128         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23129         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23130         retval = &EX_T(opline->result.var).tmp_var;
23131 
23132         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
23133                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
23134         }
23135 
23136         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
23137         object = *object_ptr;
23138 
23139         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23140                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23141 
23142                 ZVAL_NULL(retval);
23143                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23144                 CHECK_EXCEPTION();
23145                 ZEND_VM_NEXT_OPCODE();
23146         }
23147 
23148         /* here we are sure we are dealing with an object */
23149 
23150         if (0) {
23151                 MAKE_REAL_ZVAL_PTR(property);
23152         }
23153 
23154         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
23155                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23156                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
23157                         have_get_ptr = 1;
23158                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
23159 
23160                         ZVAL_COPY_VALUE(retval, *zptr);
23161                         zendi_zval_copy_ctor(*retval);
23162 
23163                         incdec_op(*zptr);
23164 
23165                 }
23166         }
23167 
23168         if (!have_get_ptr) {
23169                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
23170                         zval *z, *z_copy;
23171 
23172                         Z_ADDREF_P(object);
23173                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23174                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
23175                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
23176 
23177                                 if (Z_REFCOUNT_P(z) == 0) {
23178                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
23179                                         zval_dtor(z);
23180                                         FREE_ZVAL(z);
23181                                 }
23182                                 z = value;
23183                         }
23184                         ZVAL_COPY_VALUE(retval, z);
23185                         zendi_zval_copy_ctor(*retval);
23186                         ALLOC_ZVAL(z_copy);
23187                         INIT_PZVAL_COPY(z_copy, z);
23188                         zendi_zval_copy_ctor(*z_copy);
23189                         incdec_op(z_copy);
23190                         Z_ADDREF_P(z);
23191                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23192                         zval_ptr_dtor(&object);
23193                         zval_ptr_dtor(&z_copy);
23194                         zval_ptr_dtor(&z);
23195                 } else {
23196                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
23197                         ZVAL_NULL(retval);
23198                 }
23199         }
23200 
23201         if (0) {
23202                 zval_ptr_dtor(&property);
23203         } else {
23204 
23205         }
23206         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23207         CHECK_EXCEPTION();
23208         ZEND_VM_NEXT_OPCODE();
23209 }
23210 
23211 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23212 {
23213         return zend_post_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23214 }
23215 
23216 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23217 {
23218         return zend_post_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23219 }
23220 
23221 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23222 {
23223         USE_OPLINE
23224         zend_free_op free_op1;
23225         zval *container;
23226 
23227         SAVE_OPLINE();
23228         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23229         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
23230 
23231         if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
23232                 zval_ptr_dtor_nogc(&free_op1.var);
23233         }
23234         CHECK_EXCEPTION();
23235         ZEND_VM_NEXT_OPCODE();
23236 }
23237 
23238 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23239 {
23240         USE_OPLINE
23241         zend_free_op free_op1;
23242         zval **container;
23243 
23244         SAVE_OPLINE();
23245         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23246 
23247         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23248                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23249         }
23250         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
23251 
23252         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23253                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23254         }
23255         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23256 
23257         /* We are going to assign the result by reference */
23258         if (UNEXPECTED(opline->extended_value != 0)) {
23259                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
23260 
23261                 if (retval_ptr) {
23262                         Z_DELREF_PP(retval_ptr);
23263                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
23264                         Z_ADDREF_PP(retval_ptr);
23265                 }
23266         }
23267 
23268         CHECK_EXCEPTION();
23269         ZEND_VM_NEXT_OPCODE();
23270 }
23271 
23272 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23273 {
23274         USE_OPLINE
23275         zend_free_op free_op1;
23276         zval **container;
23277 
23278         SAVE_OPLINE();
23279         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23280 
23281         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23282                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23283         }
23284         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
23285 
23286         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23287                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23288         }
23289         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23290         CHECK_EXCEPTION();
23291         ZEND_VM_NEXT_OPCODE();
23292 }
23293 
23294 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23295 {
23296         USE_OPLINE
23297         zend_free_op free_op1;
23298         zval *container;
23299 
23300         SAVE_OPLINE();
23301         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23302         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC);
23303 
23304         zval_ptr_dtor_nogc(&free_op1.var);
23305         CHECK_EXCEPTION();
23306         ZEND_VM_NEXT_OPCODE();
23307 }
23308 
23309 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23310 {
23311         USE_OPLINE
23312         zend_free_op free_op1;
23313 
23314         SAVE_OPLINE();
23315 
23316         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
23317                 zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23318                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23319                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23320                 }
23321                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
23322                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23323                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23324                 }
23325 
23326                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23327         } else {
23328                 zval *container;
23329 
23330                 if (IS_CV == IS_UNUSED) {
23331                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
23332                 }
23333                 container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23334                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
23335 
23336                 zval_ptr_dtor_nogc(&free_op1.var);
23337         }
23338         CHECK_EXCEPTION();
23339         ZEND_VM_NEXT_OPCODE();
23340 }
23341 
23342 static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23343 {
23344         USE_OPLINE
23345         zend_free_op free_op1;
23346         zval **container;
23347 
23348         SAVE_OPLINE();
23349         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23350 
23351         if (IS_VAR == IS_CV) {
23352                 if (container != &EG(uninitialized_zval_ptr)) {
23353                         SEPARATE_ZVAL_IF_NOT_REF(container);
23354                 }
23355         }
23356         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23357                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23358         }
23359         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC);
23360 
23361         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23362                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23363         }
23364         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23365         if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
23366                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
23367                 ZEND_VM_NEXT_OPCODE();
23368         } else {
23369                 zend_free_op free_res;
23370                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
23371 
23372                 PZVAL_UNLOCK(*retval_ptr, &free_res);
23373                 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
23374                         SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
23375                 }
23376                 PZVAL_LOCK(*retval_ptr);
23377                 FREE_OP_VAR_PTR(free_res);
23378                 CHECK_EXCEPTION();
23379                 ZEND_VM_NEXT_OPCODE();
23380         }
23381 }
23382 
23383 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS)
23384 {
23385         USE_OPLINE
23386         zend_free_op free_op1;
23387         zval *container;
23388 
23389         zval *offset;
23390 
23391         SAVE_OPLINE();
23392         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23393         offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23394 
23395         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
23396             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
23397                 zend_error(E_NOTICE, "Trying to get property of non-object");
23398                 PZVAL_LOCK(&EG(uninitialized_zval));
23399                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23400 
23401         } else {
23402                 zval *retval;
23403 
23404                 if (0) {
23405                         MAKE_REAL_ZVAL_PTR(offset);
23406                 }
23407 
23408                 /* here we are sure we are dealing with an object */
23409                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23410 
23411                 PZVAL_LOCK(retval);
23412                 EX_T(opline->result.var).var.ptr = retval;
23413 
23414                 if (0) {
23415                         zval_ptr_dtor(&offset);
23416                 } else {
23417 
23418                 }
23419         }
23420 
23421         zval_ptr_dtor_nogc(&free_op1.var);
23422         CHECK_EXCEPTION();
23423         ZEND_VM_NEXT_OPCODE();
23424 }
23425 
23426 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23427 {
23428         return zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23429 }
23430 
23431 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23432 {
23433         USE_OPLINE
23434         zend_free_op free_op1;
23435         zval *property;
23436         zval **container;
23437 
23438         SAVE_OPLINE();
23439         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23440 
23441         if (0) {
23442                 MAKE_REAL_ZVAL_PTR(property);
23443         }
23444         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23445         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23446                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23447         }
23448 
23449         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
23450         if (0) {
23451                 zval_ptr_dtor(&property);
23452         } else {
23453 
23454         }
23455         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23456                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23457         }
23458         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23459 
23460         /* We are going to assign the result by reference */
23461         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
23462                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
23463 
23464                 Z_DELREF_PP(retval_ptr);
23465                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
23466                 Z_ADDREF_PP(retval_ptr);
23467                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
23468                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
23469         }
23470 
23471         CHECK_EXCEPTION();
23472         ZEND_VM_NEXT_OPCODE();
23473 }
23474 
23475 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23476 {
23477         USE_OPLINE
23478         zend_free_op free_op1;
23479         zval *property;
23480         zval **container;
23481 
23482         SAVE_OPLINE();
23483         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23484         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23485 
23486         if (0) {
23487                 MAKE_REAL_ZVAL_PTR(property);
23488         }
23489         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23490                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23491         }
23492         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
23493         if (0) {
23494                 zval_ptr_dtor(&property);
23495         } else {
23496 
23497         }
23498         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23499                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23500         }
23501         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23502         CHECK_EXCEPTION();
23503         ZEND_VM_NEXT_OPCODE();
23504 }
23505 
23506 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23507 {
23508         USE_OPLINE
23509         zend_free_op free_op1;
23510         zval *container;
23511 
23512         zval *offset;
23513 
23514         SAVE_OPLINE();
23515         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23516         offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23517 
23518         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
23519             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
23520                 PZVAL_LOCK(&EG(uninitialized_zval));
23521                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23522 
23523         } else {
23524                 zval *retval;
23525 
23526                 if (0) {
23527                         MAKE_REAL_ZVAL_PTR(offset);
23528                 }
23529 
23530                 /* here we are sure we are dealing with an object */
23531                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23532 
23533                 PZVAL_LOCK(retval);
23534                 EX_T(opline->result.var).var.ptr = retval;
23535 
23536                 if (0) {
23537                         zval_ptr_dtor(&offset);
23538                 } else {
23539 
23540                 }
23541         }
23542 
23543         zval_ptr_dtor_nogc(&free_op1.var);
23544         CHECK_EXCEPTION();
23545         ZEND_VM_NEXT_OPCODE();
23546 }
23547 
23548 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23549 {
23550         USE_OPLINE
23551 
23552         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
23553                 /* Behave like FETCH_OBJ_W */
23554                 zend_free_op free_op1;
23555                 zval *property;
23556                 zval **container;
23557 
23558                 SAVE_OPLINE();
23559                 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23560                 container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23561 
23562                 if (0) {
23563                         MAKE_REAL_ZVAL_PTR(property);
23564                 }
23565                 if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23566                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23567                 }
23568                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
23569                 if (0) {
23570                         zval_ptr_dtor(&property);
23571                 } else {
23572 
23573                 }
23574                 if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23575                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23576                 }
23577                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23578                 CHECK_EXCEPTION();
23579                 ZEND_VM_NEXT_OPCODE();
23580         } else {
23581                 return zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23582         }
23583 }
23584 
23585 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23586 {
23587         USE_OPLINE
23588         zend_free_op free_op1, free_res;
23589         zval **container;
23590         zval *property;
23591 
23592         SAVE_OPLINE();
23593         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23594         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23595 
23596         if (IS_VAR == IS_CV) {
23597                 if (container != &EG(uninitialized_zval_ptr)) {
23598                         SEPARATE_ZVAL_IF_NOT_REF(container);
23599                 }
23600         }
23601         if (0) {
23602                 MAKE_REAL_ZVAL_PTR(property);
23603         }
23604         if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
23605                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
23606         }
23607         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
23608         if (0) {
23609                 zval_ptr_dtor(&property);
23610         } else {
23611 
23612         }
23613         if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
23614                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
23615         }
23616         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23617 
23618         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
23619         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
23620                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
23621         }
23622         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
23623         FREE_OP_VAR_PTR(free_res);
23624         CHECK_EXCEPTION();
23625         ZEND_VM_NEXT_OPCODE();
23626 }
23627 
23628 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23629 {
23630         USE_OPLINE
23631         zend_free_op free_op1;
23632         zval **object_ptr;
23633         zval *property_name;
23634 
23635         SAVE_OPLINE();
23636         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23637         property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23638 
23639         if (0) {
23640                 MAKE_REAL_ZVAL_PTR(property_name);
23641         }
23642         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
23643                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23644         }
23645         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23646         if (0) {
23647                 zval_ptr_dtor(&property_name);
23648         } else {
23649 
23650         }
23651         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23652         /* assign_obj has two opcodes! */
23653         CHECK_EXCEPTION();
23654         ZEND_VM_INC_OPCODE();
23655         ZEND_VM_NEXT_OPCODE();
23656 }
23657 
23658 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23659 {
23660         USE_OPLINE
23661         zend_free_op free_op1;
23662         zval **object_ptr;
23663 
23664         SAVE_OPLINE();
23665         object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23666 
23667         if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
23668                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
23669         }
23670         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
23671 
23672                 zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23673 
23674                 if (0) {
23675                         MAKE_REAL_ZVAL_PTR(property_name);
23676                 }
23677                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
23678                 if (0) {
23679                         zval_ptr_dtor(&property_name);
23680                 } else {
23681 
23682                 }
23683         } else {
23684                 zend_free_op free_op_data1, free_op_data2;
23685                 zval *value;
23686                 zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23687                 zval **variable_ptr_ptr;
23688 
23689                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC);
23690 
23691                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
23692                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
23693                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
23694                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
23695                                 if (RETURN_VALUE_USED(opline)) {
23696                                         zval *retval;
23697 
23698                                         ALLOC_ZVAL(retval);
23699                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
23700                                         INIT_PZVAL(retval);
23701                                         EX_T(opline->result.var).var.ptr = retval;
23702                                 }
23703                         } else if (RETURN_VALUE_USED(opline)) {
23704                                 PZVAL_LOCK(&EG(uninitialized_zval));
23705                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23706                         }
23707                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
23708                         if (IS_TMP_FREE(free_op_data1)) {
23709                                 zval_dtor(value);
23710                         }
23711                         if (RETURN_VALUE_USED(opline)) {
23712                                 PZVAL_LOCK(&EG(uninitialized_zval));
23713                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23714                         }
23715                 } else {
23716                         if ((opline+1)->op1_type == IS_TMP_VAR) {
23717                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23718                         } else if ((opline+1)->op1_type == IS_CONST) {
23719                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23720                         } else {
23721                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23722                         }
23723                         if (RETURN_VALUE_USED(opline)) {
23724                                 PZVAL_LOCK(value);
23725                                 EX_T(opline->result.var).var.ptr = value;
23726                         }
23727                 }
23728                 FREE_OP_VAR_PTR(free_op_data2);
23729                 FREE_OP_IF_VAR(free_op_data1);
23730         }
23731         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23732         /* assign_dim has two opcodes! */
23733         CHECK_EXCEPTION();
23734         ZEND_VM_INC_OPCODE();
23735         ZEND_VM_NEXT_OPCODE();
23736 }
23737 
23738 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23739 {
23740         USE_OPLINE
23741         zend_free_op free_op1;
23742         zval *value;
23743         zval **variable_ptr_ptr;
23744 
23745         SAVE_OPLINE();
23746         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23747         variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23748 
23749         if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
23750                 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) {
23751                         if (RETURN_VALUE_USED(opline)) {
23752                                 zval *retval;
23753 
23754                                 ALLOC_ZVAL(retval);
23755                                 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
23756                                 INIT_PZVAL(retval);
23757                                 EX_T(opline->result.var).var.ptr = retval;
23758                         }
23759                 } else if (RETURN_VALUE_USED(opline)) {
23760                         PZVAL_LOCK(&EG(uninitialized_zval));
23761                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23762                 }
23763         } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
23764                 if (0) {
23765                         zval_dtor(value);
23766                 }
23767                 if (RETURN_VALUE_USED(opline)) {
23768                         PZVAL_LOCK(&EG(uninitialized_zval));
23769                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
23770                 }
23771         } else {
23772                 if (IS_CV == IS_TMP_VAR) {
23773                         value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23774                 } else if (IS_CV == IS_CONST) {
23775                         value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23776                 } else {
23777                         value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
23778                 }
23779                 if (RETURN_VALUE_USED(opline)) {
23780                         PZVAL_LOCK(value);
23781                         EX_T(opline->result.var).var.ptr = value;
23782                 }
23783         }
23784 
23785         if (IS_VAR == IS_VAR && (free_op1.var != NULL)) {
23786                 zval_ptr_dtor_nogc(&value);
23787         }
23788 
23789         /* zend_assign_to_variable() always takes care of op2, never free it! */
23790 
23791         CHECK_EXCEPTION();
23792         ZEND_VM_NEXT_OPCODE();
23793 }
23794 
23795 static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23796 {
23797         USE_OPLINE
23798         zend_free_op free_op1, free_op2;
23799         zval **variable_ptr_ptr;
23800         zval **value_ptr_ptr;
23801 
23802         SAVE_OPLINE();
23803         value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC);
23804 
23805         if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
23806                 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
23807         }
23808 
23809         if (IS_CV == IS_VAR &&
23810             value_ptr_ptr &&
23811             !Z_ISREF_PP(value_ptr_ptr) &&
23812             opline->extended_value == ZEND_RETURNS_FUNCTION &&
23813             !EX_T(opline->op2.var).var.fcall_returned_reference) {
23814                 if (free_op2.var == NULL) {
23815                         PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
23816                 }
23817                 zend_error(E_STRICT, "Only variables should be assigned by reference");
23818                 if (UNEXPECTED(EG(exception) != NULL)) {
23819 
23820                         HANDLE_EXCEPTION();
23821                 }
23822                 return ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
23823         } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
23824                 PZVAL_LOCK(*value_ptr_ptr);
23825         }
23826 
23827         variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23828         if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
23829             (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
23830                 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
23831         }
23832         zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
23833 
23834         if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
23835                 Z_DELREF_PP(variable_ptr_ptr);
23836         }
23837 
23838         if (RETURN_VALUE_USED(opline)) {
23839                 PZVAL_LOCK(*variable_ptr_ptr);
23840                 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
23841         }
23842 
23843         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
23844 
23845         CHECK_EXCEPTION();
23846         ZEND_VM_NEXT_OPCODE();
23847 }
23848 
23849 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23850 {
23851         USE_OPLINE
23852         zval *function_name;
23853         char *function_name_strval;
23854         int function_name_strlen;
23855         zend_free_op free_op1;
23856         call_slot *call = EX(call_slots) + opline->result.num;
23857 
23858         SAVE_OPLINE();
23859 
23860         function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23861 
23862         if (IS_CV != IS_CONST &&
23863             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
23864                 if (UNEXPECTED(EG(exception) != NULL)) {
23865                         HANDLE_EXCEPTION();
23866                 }
23867                 zend_error_noreturn(E_ERROR, "Method name must be a string");
23868         }
23869 
23870         function_name_strval = Z_STRVAL_P(function_name);
23871         function_name_strlen = Z_STRLEN_P(function_name);
23872 
23873         call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
23874 
23875         if (EXPECTED(call->object != NULL) &&
23876             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
23877                 call->called_scope = Z_OBJCE_P(call->object);
23878 
23879                 if (IS_CV != IS_CONST ||
23880                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
23881                     zval *object = call->object;
23882 
23883                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
23884                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
23885                         }
23886 
23887                         /* First, locate the function. */
23888                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
23889                         if (UNEXPECTED(call->fbc == NULL)) {
23890                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
23891                         }
23892                         if (IS_CV == IS_CONST &&
23893                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
23894                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
23895                             EXPECTED(call->object == object)) {
23896                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
23897                         }
23898                 }
23899         } else {
23900                 if (UNEXPECTED(EG(exception) != NULL)) {
23901 
23902                         HANDLE_EXCEPTION();
23903                 }
23904                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
23905         }
23906 
23907         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
23908                 call->object = NULL;
23909         } else {
23910                 if (!PZVAL_IS_REF(call->object)) {
23911                         Z_ADDREF_P(call->object); /* For $this pointer */
23912                 } else {
23913                         zval *this_ptr;
23914                         ALLOC_ZVAL(this_ptr);
23915                         INIT_PZVAL_COPY(this_ptr, call->object);
23916                         zval_copy_ctor(this_ptr);
23917                         call->object = this_ptr;
23918                 }
23919         }
23920 
23921         call->num_additional_args = 0;
23922         call->is_ctor_call = 0;
23923         EX(call) = call;
23924 
23925         zval_ptr_dtor_nogc(&free_op1.var);
23926 
23927         CHECK_EXCEPTION();
23928         ZEND_VM_NEXT_OPCODE();
23929 }
23930 
23931 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23932 {
23933         USE_OPLINE
23934         zval *function_name;
23935         zend_class_entry *ce;
23936         call_slot *call = EX(call_slots) + opline->result.num;
23937 
23938         SAVE_OPLINE();
23939 
23940         if (IS_VAR == IS_CONST) {
23941                 /* no function found. try a static method in class */
23942                 if (CACHED_PTR(opline->op1.literal->cache_slot)) {
23943                         ce = CACHED_PTR(opline->op1.literal->cache_slot);
23944                 } else {
23945                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
23946                         if (UNEXPECTED(EG(exception) != NULL)) {
23947                                 HANDLE_EXCEPTION();
23948                         }
23949                         if (UNEXPECTED(ce == NULL)) {
23950                                 zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
23951                         }
23952                         CACHE_PTR(opline->op1.literal->cache_slot, ce);
23953                 }
23954                 call->called_scope = ce;
23955         } else {
23956                 ce = EX_T(opline->op1.var).class_entry;
23957 
23958                 if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
23959                         call->called_scope = EG(called_scope);
23960                 } else {
23961                         call->called_scope = ce;
23962                 }
23963         }
23964 
23965         if (IS_VAR == IS_CONST &&
23966             IS_CV == IS_CONST &&
23967             CACHED_PTR(opline->op2.literal->cache_slot)) {
23968                 call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
23969         } else if (IS_VAR != IS_CONST &&
23970                    IS_CV == IS_CONST &&
23971                    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
23972                 /* do nothing */
23973         } else if (IS_CV != IS_UNUSED) {
23974                 char *function_name_strval = NULL;
23975                 int function_name_strlen = 0;
23976 
23977 
23978                 if (IS_CV == IS_CONST) {
23979                         function_name_strval = Z_STRVAL_P(opline->op2.zv);
23980                         function_name_strlen = Z_STRLEN_P(opline->op2.zv);
23981                 } else {
23982                         function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
23983 
23984                         if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
23985                                 if (UNEXPECTED(EG(exception) != NULL)) {
23986                                         HANDLE_EXCEPTION();
23987                                 }
23988                                 zend_error_noreturn(E_ERROR, "Function name must be a string");
23989                         } else {
23990                                 function_name_strval = Z_STRVAL_P(function_name);
23991                                 function_name_strlen = Z_STRLEN_P(function_name);
23992                         }
23993                 }
23994 
23995                 if (function_name_strval) {
23996                         if (ce->get_static_method) {
23997                                 call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
23998                         } else {
23999                                 call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
24000                         }
24001                         if (UNEXPECTED(call->fbc == NULL)) {
24002                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
24003                         }
24004                         if (IS_CV == IS_CONST &&
24005                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
24006                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
24007                                 if (IS_VAR == IS_CONST) {
24008                                         CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
24009                                 } else {
24010                                         CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
24011                                 }
24012                         }
24013                 }
24014                 if (IS_CV != IS_CONST) {
24015 
24016                 }
24017         } else {
24018                 if (UNEXPECTED(ce->constructor == NULL)) {
24019                         zend_error_noreturn(E_ERROR, "Cannot call constructor");
24020                 }
24021                 if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
24022                         zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
24023                 }
24024                 call->fbc = ce->constructor;
24025         }
24026 
24027         if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
24028                 call->object = NULL;
24029         } else {
24030                 if (EG(This) &&
24031                     Z_OBJ_HT_P(EG(This))->get_class_entry &&
24032                     !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
24033                     /* We are calling method of the other (incompatible) class,
24034                        but passing $this. This is done for compatibility with php-4. */
24035                         if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
24036                                 zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
24037                         } else {
24038                                 /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
24039                                 zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
24040                         }
24041                 }
24042                 if ((call->object = EG(This))) {
24043                         Z_ADDREF_P(call->object);
24044                         call->called_scope = Z_OBJCE_P(call->object);
24045                 }
24046         }
24047 
24048         call->num_additional_args = 0;
24049         call->is_ctor_call = 0;
24050         EX(call) = call;
24051 
24052         CHECK_EXCEPTION();
24053         ZEND_VM_NEXT_OPCODE();
24054 }
24055 
24056 static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24057 {
24058         USE_OPLINE
24059         zend_free_op free_op1;
24060 
24061         SAVE_OPLINE();
24062         is_equal_function(&EX_T(opline->result.var).tmp_var,
24063                                  _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
24064                                  _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
24065 
24066         CHECK_EXCEPTION();
24067         ZEND_VM_NEXT_OPCODE();
24068 }
24069 
24070 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24071 {
24072         USE_OPLINE
24073         zend_free_op free_op1;
24074         zval *expr_ptr;
24075 
24076         SAVE_OPLINE();
24077         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
24078                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24079 
24080                 if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
24081                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
24082                 }
24083                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
24084                 expr_ptr = *expr_ptr_ptr;
24085                 Z_ADDREF_P(expr_ptr);
24086         } else {
24087                 expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24088                 if (0) { /* temporary variable */
24089                         zval *new_expr;
24090 
24091                         ALLOC_ZVAL(new_expr);
24092                         INIT_PZVAL_COPY(new_expr, expr_ptr);
24093                         expr_ptr = new_expr;
24094                 } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
24095                         zval *new_expr;
24096 
24097                         ALLOC_ZVAL(new_expr);
24098                         INIT_PZVAL_COPY(new_expr, expr_ptr);
24099                         expr_ptr = new_expr;
24100                         zendi_zval_copy_ctor(*expr_ptr);
24101                         zval_ptr_dtor_nogc(&free_op1.var);
24102                 } else if (IS_VAR == IS_CV) {
24103                         Z_ADDREF_P(expr_ptr);
24104                 }
24105         }
24106 
24107         if (IS_CV != IS_UNUSED) {
24108 
24109                 zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24110                 ulong hval;
24111 
24112                 switch (Z_TYPE_P(offset)) {
24113                         case IS_DOUBLE:
24114                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
24115                                 goto num_index;
24116                         case IS_LONG:
24117                         case IS_BOOL:
24118                                 hval = Z_LVAL_P(offset);
24119 num_index:
24120                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
24121                                 break;
24122                         case IS_STRING:
24123                                 if (IS_CV == IS_CONST) {
24124                                         hval = Z_HASH_P(offset);
24125                                 } else {
24126                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
24127                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
24128                                 }
24129                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
24130                                 break;
24131                         case IS_NULL:
24132                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
24133                                 break;
24134                         default:
24135                                 zend_error(E_WARNING, "Illegal offset type");
24136                                 zval_ptr_dtor(&expr_ptr);
24137                                 /* do nothing */
24138                                 break;
24139                 }
24140 
24141         } else {
24142                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
24143         }
24144         if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
24145                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
24146         }
24147         CHECK_EXCEPTION();
24148         ZEND_VM_NEXT_OPCODE();
24149 }
24150 
24151 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24152 {
24153         USE_OPLINE
24154 
24155         array_init(&EX_T(opline->result.var).tmp_var);
24156         if (IS_VAR == IS_UNUSED) {
24157                 ZEND_VM_NEXT_OPCODE();
24158 #if 0 || IS_VAR != IS_UNUSED
24159         } else {
24160                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24161 #endif
24162         }
24163 }
24164 
24165 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24166 {
24167         USE_OPLINE
24168         zend_free_op free_op1;
24169         zval **container;
24170         zval *offset;
24171         ulong hval;
24172 
24173         SAVE_OPLINE();
24174         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24175         if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
24176                 SEPARATE_ZVAL_IF_NOT_REF(container);
24177         }
24178         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24179 
24180         if (IS_VAR != IS_VAR || container) {
24181                 switch (Z_TYPE_PP(container)) {
24182                         case IS_ARRAY: {
24183                                 HashTable *ht = Z_ARRVAL_PP(container);
24184 
24185                                 switch (Z_TYPE_P(offset)) {
24186                                         case IS_DOUBLE:
24187                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
24188                                                 zend_hash_index_del(ht, hval);
24189                                                 break;
24190                                         case IS_RESOURCE:
24191                                         case IS_BOOL:
24192                                         case IS_LONG:
24193                                                 hval = Z_LVAL_P(offset);
24194                                                 zend_hash_index_del(ht, hval);
24195                                                 break;
24196                                         case IS_STRING:
24197                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24198                                                         Z_ADDREF_P(offset);
24199                                                 }
24200                                                 if (IS_CV == IS_CONST) {
24201                                                         hval = Z_HASH_P(offset);
24202                                                 } else {
24203                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
24204                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
24205                                                 }
24206                                                 if (ht == &EG(symbol_table)) {
24207                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
24208                                                 } else {
24209                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
24210                                                 }
24211                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24212                                                         zval_ptr_dtor(&offset);
24213                                                 }
24214                                                 break;
24215 num_index_dim:
24216                                                 zend_hash_index_del(ht, hval);
24217                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24218                                                         zval_ptr_dtor(&offset);
24219                                                 }
24220                                                 break;
24221                                         case IS_NULL:
24222                                                 zend_hash_del(ht, "", sizeof(""));
24223                                                 break;
24224                                         default:
24225                                                 zend_error(E_WARNING, "Illegal offset type in unset");
24226                                                 break;
24227                                 }
24228 
24229                                 break;
24230                         }
24231                         case IS_OBJECT:
24232                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
24233                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
24234                                 }
24235                                 if (0) {
24236                                         MAKE_REAL_ZVAL_PTR(offset);
24237                                 }
24238                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
24239                                 if (0) {
24240                                         zval_ptr_dtor(&offset);
24241                                 } else {
24242 
24243                                 }
24244                                 break;
24245                         case IS_STRING:
24246                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
24247                                 ZEND_VM_CONTINUE(); /* bailed out before */
24248                         default:
24249 
24250                                 break;
24251                 }
24252         } else {
24253 
24254         }
24255         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
24256 
24257         CHECK_EXCEPTION();
24258         ZEND_VM_NEXT_OPCODE();
24259 }
24260 
24261 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24262 {
24263         USE_OPLINE
24264         zend_free_op free_op1;
24265         zval **container;
24266         zval *offset;
24267 
24268         SAVE_OPLINE();
24269         container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24270         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24271 
24272         if (IS_VAR != IS_VAR || container) {
24273                 if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
24274                         SEPARATE_ZVAL_IF_NOT_REF(container);
24275                 }
24276                 if (Z_TYPE_PP(container) == IS_OBJECT) {
24277                         if (0) {
24278                                 MAKE_REAL_ZVAL_PTR(offset);
24279                         }
24280                         if (Z_OBJ_HT_P(*container)->unset_property) {
24281                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24282                         } else {
24283                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
24284                         }
24285                         if (0) {
24286                                 zval_ptr_dtor(&offset);
24287                         } else {
24288 
24289                         }
24290                 } else {
24291 
24292                 }
24293         } else {
24294 
24295         }
24296         if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
24297 
24298         CHECK_EXCEPTION();
24299         ZEND_VM_NEXT_OPCODE();
24300 }
24301 
24302 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
24303 {
24304         USE_OPLINE
24305         zend_free_op free_op1;
24306         zval *container;
24307         zval **value = NULL;
24308         int result = 0;
24309         ulong hval;
24310         zval *offset;
24311 
24312         SAVE_OPLINE();
24313         container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24314         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24315 
24316         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
24317                 HashTable *ht;
24318                 int isset = 0;
24319 
24320                 ht = Z_ARRVAL_P(container);
24321 
24322                 switch (Z_TYPE_P(offset)) {
24323                         case IS_DOUBLE:
24324                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
24325                                 goto num_index_prop;
24326                         case IS_RESOURCE:
24327                         case IS_BOOL:
24328                         case IS_LONG:
24329                                 hval = Z_LVAL_P(offset);
24330 num_index_prop:
24331                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
24332                                         isset = 1;
24333                                 }
24334                                 break;
24335                         case IS_STRING:
24336                                 if (IS_CV == IS_CONST) {
24337                                         hval = Z_HASH_P(offset);
24338                                 } else {
24339                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
24340                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
24341                                 }
24342                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
24343                                         isset = 1;
24344                                 }
24345                                 break;
24346                         case IS_NULL:
24347                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
24348                                         isset = 1;
24349                                 }
24350                                 break;
24351                         default:
24352                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
24353                                 break;
24354                 }
24355 
24356                 if (opline->extended_value & ZEND_ISSET) {
24357                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
24358                                 result = 0;
24359                         } else {
24360                                 result = isset;
24361                         }
24362                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
24363                         if (!isset || !i_zend_is_true(*value)) {
24364                                 result = 0;
24365                         } else {
24366                                 result = 1;
24367                         }
24368                 }
24369 
24370         } else if (Z_TYPE_P(container) == IS_OBJECT) {
24371                 if (0) {
24372                         MAKE_REAL_ZVAL_PTR(offset);
24373                 }
24374                 if (prop_dim) {
24375                         if (Z_OBJ_HT_P(container)->has_property) {
24376                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24377                         } else {
24378                                 zend_error(E_NOTICE, "Trying to check property of non-object");
24379                                 result = 0;
24380                         }
24381                 } else {
24382                         if (Z_OBJ_HT_P(container)->has_dimension) {
24383                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
24384                         } else {
24385                                 zend_error(E_NOTICE, "Trying to check element of non-array");
24386                                 result = 0;
24387                         }
24388                 }
24389                 if (0) {
24390                         zval_ptr_dtor(&offset);
24391                 } else {
24392 
24393                 }
24394         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
24395                 zval tmp;
24396 
24397                 if (Z_TYPE_P(offset) != IS_LONG) {
24398                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
24399                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
24400                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
24401                                 ZVAL_COPY_VALUE(&tmp, offset);
24402                                 zval_copy_ctor(&tmp);
24403                                 convert_to_long(&tmp);
24404                                 offset = &tmp;
24405                         } else {
24406                                 /* can not be converted to proper offset, return "not set" */
24407                                 result = 0;
24408                         }
24409                 }
24410                 if (Z_TYPE_P(offset) == IS_LONG) {
24411                         if (opline->extended_value & ZEND_ISSET) {
24412                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
24413                                         result = 1;
24414                                 }
24415                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
24416                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
24417                                         result = 1;
24418                                 }
24419                         }
24420                 }
24421 
24422         } else {
24423 
24424         }
24425 
24426         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
24427         if (opline->extended_value & ZEND_ISSET) {
24428                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
24429         } else {
24430                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
24431         }
24432 
24433         zval_ptr_dtor_nogc(&free_op1.var);
24434 
24435         CHECK_EXCEPTION();
24436         ZEND_VM_NEXT_OPCODE();
24437 }
24438 
24439 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24440 {
24441         return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24442 }
24443 
24444 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24445 {
24446         return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24447 }
24448 
24449 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24450 {
24451         USE_OPLINE
24452 
24453         /* The generator object is stored in return_value_ptr_ptr */
24454         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
24455 
24456         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
24457                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
24458         }
24459 
24460         /* Destroy the previously yielded value */
24461         if (generator->value) {
24462                 zval_ptr_dtor(&generator->value);
24463         }
24464 
24465         /* Destroy the previously yielded key */
24466         if (generator->key) {
24467                 zval_ptr_dtor(&generator->key);
24468         }
24469 
24470         /* Set the new yielded value */
24471         if (IS_VAR != IS_UNUSED) {
24472                 zend_free_op free_op1;
24473 
24474                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
24475                         /* Constants and temporary variables aren't yieldable by reference,
24476                          * but we still allow them with a notice. */
24477                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
24478                                 zval *value, *copy;
24479 
24480                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
24481 
24482                                 value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24483                                 ALLOC_ZVAL(copy);
24484                                 INIT_PZVAL_COPY(copy, value);
24485 
24486                                 /* Temporary variables don't need ctor copying */
24487                                 if (!0) {
24488                                         zval_copy_ctor(copy);
24489                                 }
24490 
24491                                 generator->value = copy;
24492                         } else {
24493                                 zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24494 
24495                                 if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
24496                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
24497                                 }
24498 
24499                                 /* If a function call result is yielded and the function did
24500                                  * not return by reference we throw a notice. */
24501                                 if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
24502                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
24503                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
24504                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
24505                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
24506 
24507                                         Z_ADDREF_PP(value_ptr);
24508                                         generator->value = *value_ptr;
24509                                 } else {
24510                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
24511                                         Z_ADDREF_PP(value_ptr);
24512                                         generator->value = *value_ptr;
24513                                 }
24514 
24515                                 if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
24516                         }
24517                 } else {
24518                         zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
24519 
24520                         /* Consts, temporary variables and references need copying */
24521                         if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
24522                                 || PZVAL_IS_REF(value)
24523                         ) {
24524                                 zval *copy;
24525 
24526                                 ALLOC_ZVAL(copy);
24527                                 INIT_PZVAL_COPY(copy, value);
24528 
24529                                 /* Temporary variables don't need ctor copying */
24530                                 if (!0) {
24531                                         zval_copy_ctor(copy);
24532                                 }
24533 
24534                                 generator->value = copy;
24535                                 zval_ptr_dtor_nogc(&free_op1.var);
24536                         } else {
24537                                 if (IS_VAR == IS_CV) {
24538                                         Z_ADDREF_P(value);
24539                                 }
24540                                 generator->value = value;
24541                         }
24542                 }
24543         } else {
24544                 /* If no value was specified yield null */
24545                 Z_ADDREF(EG(uninitialized_zval));
24546                 generator->value = &EG(uninitialized_zval);
24547         }
24548 
24549         /* Set the new yielded key */
24550         if (IS_CV != IS_UNUSED) {
24551 
24552                 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
24553 
24554                 /* Consts, temporary variables and references need copying */
24555                 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
24556                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
24557                 ) {
24558                         zval *copy;
24559 
24560                         ALLOC_ZVAL(copy);
24561                         INIT_PZVAL_COPY(copy, key);
24562 
24563                         /* Temporary variables don't need ctor copying */
24564                         if (!0) {
24565                                 zval_copy_ctor(copy);
24566                         }
24567 
24568                         generator->key = copy;
24569                 } else {
24570                         Z_ADDREF_P(key);
24571                         generator->key = key;
24572                 }
24573 
24574                 if (Z_TYPE_P(generator->key) == IS_LONG
24575                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
24576                 ) {
24577                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
24578                 }
24579 
24580         } else {
24581                 /* If no key was specified we use auto-increment keys */
24582                 generator->largest_used_integer_key++;
24583 
24584                 ALLOC_INIT_ZVAL(generator->key);
24585                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
24586         }
24587 
24588         if (RETURN_VALUE_USED(opline)) {
24589                 /* If the return value of yield is used set the send
24590                  * target and initialize it to NULL */
24591                 generator->send_target = &EX_T(opline->result.var).var.ptr;
24592                 Z_ADDREF(EG(uninitialized_zval));
24593                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
24594         } else {
24595                 generator->send_target = NULL;
24596         }
24597 
24598         /* We increment to the next op, so we are at the correct position when the
24599          * generator is resumed. */
24600         ZEND_VM_INC_OPCODE();
24601 
24602         /* The GOTO VM uses a local opline variable. We need to set the opline
24603          * variable in execute_data so we don't resume at an old position. */
24604         SAVE_OPLINE();
24605 
24606         ZEND_VM_RETURN();
24607 }
24608 
24609 static int ZEND_FASTCALL  ZEND_POW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24610 {
24611         USE_OPLINE
24612         zend_free_op free_op1;
24613 
24614         SAVE_OPLINE();
24615         pow_function(&EX_T(opline->result.var).tmp_var,
24616                 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
24617                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
24618         zval_ptr_dtor_nogc(&free_op1.var);
24619 
24620         CHECK_EXCEPTION();
24621         ZEND_VM_NEXT_OPCODE();
24622 }
24623 
24624 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24625 {
24626         return zend_binary_assign_op_helper_SPEC_VAR_CV(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24627 }
24628 
24629 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24630 {
24631         USE_OPLINE
24632 
24633         zval *obj;
24634         zend_class_entry *ce;
24635         zend_function *clone;
24636         zend_object_clone_obj_t clone_call;
24637 
24638         SAVE_OPLINE();
24639         obj = _get_obj_zval_ptr_unused(TSRMLS_C);
24640 
24641         if (IS_UNUSED == IS_CONST ||
24642             UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
24643                 if (UNEXPECTED(EG(exception) != NULL)) {
24644                         HANDLE_EXCEPTION();
24645                 }
24646                 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
24647         }
24648 
24649         ce = Z_OBJCE_P(obj);
24650         clone = ce ? ce->clone : NULL;
24651         clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
24652         if (UNEXPECTED(clone_call == NULL)) {
24653                 if (ce) {
24654                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
24655                 } else {
24656                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
24657                 }
24658         }
24659 
24660         if (ce && clone) {
24661                 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
24662                         /* Ensure that if we're calling a private function, we're allowed to do so.
24663                          */
24664                         if (UNEXPECTED(ce != EG(scope))) {
24665                                 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
24666                         }
24667                 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
24668                         /* Ensure that if we're calling a protected function, we're allowed to do so.
24669                          */
24670                         if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
24671                                 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
24672                         }
24673                 }
24674         }
24675 
24676         if (EXPECTED(EG(exception) == NULL)) {
24677                 zval *retval;
24678 
24679                 ALLOC_ZVAL(retval);
24680                 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
24681                 Z_TYPE_P(retval) = IS_OBJECT;
24682                 Z_SET_REFCOUNT_P(retval, 1);
24683                 Z_SET_ISREF_P(retval);
24684                 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
24685                         zval_ptr_dtor(&retval);
24686                 } else {
24687                         EX_T(opline->result.var).var.ptr = retval;
24688                 }
24689         }
24690 
24691         CHECK_EXCEPTION();
24692         ZEND_VM_NEXT_OPCODE();
24693 }
24694 
24695 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24696 {
24697 #if 0 || (IS_UNUSED != IS_UNUSED)
24698         USE_OPLINE
24699 
24700         SAVE_OPLINE();
24701         if (IS_UNUSED != IS_UNUSED) {
24702 
24703                 zval *ptr = NULL;
24704 
24705                 if (Z_TYPE_P(ptr) == IS_LONG) {
24706                         EG(exit_status) = Z_LVAL_P(ptr);
24707                 } else {
24708                         zend_print_variable(ptr);
24709                 }
24710 
24711         }
24712 #endif
24713         zend_bailout();
24714         ZEND_VM_NEXT_OPCODE(); /* Never reached */
24715 }
24716 
24717 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
24718 {
24719         USE_OPLINE
24720         zend_free_op free_op_data1;
24721         zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
24722         zval *object;
24723         zval *property = opline->op2.zv;
24724         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
24725         int have_get_ptr = 0;
24726 
24727         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
24728                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
24729         }
24730 
24731         make_real_object(object_ptr TSRMLS_CC);
24732         object = *object_ptr;
24733 
24734         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24735                 zend_error(E_WARNING, "Attempt to assign property of non-object");
24736 
24737                 FREE_OP(free_op_data1);
24738 
24739                 if (RETURN_VALUE_USED(opline)) {
24740                         PZVAL_LOCK(&EG(uninitialized_zval));
24741                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
24742                 }
24743         } else {
24744                 /* here we are sure we are dealing with an object */
24745                 if (0) {
24746                         MAKE_REAL_ZVAL_PTR(property);
24747                 }
24748 
24749                 /* here property is a string */
24750                 if (opline->extended_value == ZEND_ASSIGN_OBJ
24751                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
24752                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24753                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
24754                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
24755 
24756                                 have_get_ptr = 1;
24757                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
24758                                 if (RETURN_VALUE_USED(opline)) {
24759                                         PZVAL_LOCK(*zptr);
24760                                         EX_T(opline->result.var).var.ptr = *zptr;
24761                                 }
24762                         }
24763                 }
24764 
24765                 if (!have_get_ptr) {
24766                         zval *z = NULL;
24767 
24768                         Z_ADDREF_P(object);
24769                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
24770                                 if (Z_OBJ_HT_P(object)->read_property) {
24771                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24772                                 }
24773                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
24774                                 if (Z_OBJ_HT_P(object)->read_dimension) {
24775                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
24776                                 }
24777                         }
24778                         if (z) {
24779                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
24780                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
24781 
24782                                         if (Z_REFCOUNT_P(z) == 0) {
24783                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
24784                                                 zval_dtor(z);
24785                                                 FREE_ZVAL(z);
24786                                         }
24787                                         z = value;
24788                                 }
24789                                 Z_ADDREF_P(z);
24790                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
24791                                 binary_op(z, z, value TSRMLS_CC);
24792                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
24793                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
24794                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
24795                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
24796                                 }
24797                                 if (RETURN_VALUE_USED(opline)) {
24798                                         PZVAL_LOCK(z);
24799                                         EX_T(opline->result.var).var.ptr = z;
24800                                 }
24801                                 zval_ptr_dtor(&z);
24802                         } else {
24803                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
24804                                 if (RETURN_VALUE_USED(opline)) {
24805                                         PZVAL_LOCK(&EG(uninitialized_zval));
24806                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
24807                                 }
24808                         }
24809                         zval_ptr_dtor(&object);
24810                 }
24811 
24812                 if (0) {
24813                         zval_ptr_dtor(&property);
24814                 } else {
24815 
24816                 }
24817                 FREE_OP(free_op_data1);
24818         }
24819 
24820         /* assign_obj has two opcodes! */
24821         CHECK_EXCEPTION();
24822         ZEND_VM_INC_OPCODE();
24823         ZEND_VM_NEXT_OPCODE();
24824 }
24825 
24826 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
24827 {
24828         USE_OPLINE
24829         zend_free_op free_op_data2, free_op_data1;
24830         zval **var_ptr;
24831         zval *value;
24832 
24833         SAVE_OPLINE();
24834         switch (opline->extended_value) {
24835                 case ZEND_ASSIGN_OBJ:
24836                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24837                         break;
24838                 case ZEND_ASSIGN_DIM: {
24839                                 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
24840 
24841                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
24842                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
24843                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
24844                                         if (IS_UNUSED == IS_VAR && !0) {
24845                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
24846                                         }
24847                                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24848                                 } else {
24849                                         zval *dim = opline->op2.zv;
24850 
24851                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
24852                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
24853                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
24854                                 }
24855                         }
24856                         break;
24857                 default:
24858                         value = opline->op2.zv;
24859                         var_ptr = NULL;
24860                         /* do nothing */
24861                         break;
24862         }
24863 
24864         if (UNEXPECTED(var_ptr == NULL)) {
24865                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
24866         }
24867 
24868         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
24869                 if (RETURN_VALUE_USED(opline)) {
24870                         PZVAL_LOCK(&EG(uninitialized_zval));
24871                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
24872                 }
24873 
24874 
24875                 CHECK_EXCEPTION();
24876                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
24877                         ZEND_VM_INC_OPCODE();
24878                 }
24879                 ZEND_VM_NEXT_OPCODE();
24880         }
24881 
24882         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
24883 
24884         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
24885            && Z_OBJ_HANDLER_PP(var_ptr, get)
24886            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
24887                 /* proxy object */
24888                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
24889                 Z_ADDREF_P(objval);
24890                 binary_op(objval, objval, value TSRMLS_CC);
24891                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
24892                 zval_ptr_dtor(&objval);
24893         } else {
24894                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
24895         }
24896 
24897         if (RETURN_VALUE_USED(opline)) {
24898                 PZVAL_LOCK(*var_ptr);
24899                 EX_T(opline->result.var).var.ptr = *var_ptr;
24900         }
24901 
24902         if (opline->extended_value == ZEND_ASSIGN_DIM) {
24903                 FREE_OP(free_op_data1);
24904                 FREE_OP_VAR_PTR(free_op_data2);
24905 
24906                 CHECK_EXCEPTION();
24907                 ZEND_VM_INC_OPCODE();
24908         } else {
24909 
24910                 CHECK_EXCEPTION();
24911         }
24912         ZEND_VM_NEXT_OPCODE();
24913 }
24914 
24915 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24916 {
24917         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24918 }
24919 
24920 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24921 {
24922         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24923 }
24924 
24925 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24926 {
24927         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24928 }
24929 
24930 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24931 {
24932         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24933 }
24934 
24935 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24936 {
24937         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24938 }
24939 
24940 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24941 {
24942         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24943 }
24944 
24945 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24946 {
24947         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24948 }
24949 
24950 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24951 {
24952         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24953 }
24954 
24955 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24956 {
24957         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24958 }
24959 
24960 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24961 {
24962         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24963 }
24964 
24965 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24966 {
24967         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
24968 }
24969 
24970 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
24971 {
24972         USE_OPLINE
24973 
24974         zval **object_ptr;
24975         zval *object;
24976         zval *property;
24977         zval **retval;
24978         int have_get_ptr = 0;
24979 
24980         SAVE_OPLINE();
24981         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
24982         property = opline->op2.zv;
24983         retval = &EX_T(opline->result.var).var.ptr;
24984 
24985         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
24986                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
24987         }
24988 
24989         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
24990         object = *object_ptr;
24991 
24992         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24993                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
24994 
24995                 if (RETURN_VALUE_USED(opline)) {
24996                         PZVAL_LOCK(&EG(uninitialized_zval));
24997                         *retval = &EG(uninitialized_zval);
24998                 }
24999 
25000                 CHECK_EXCEPTION();
25001                 ZEND_VM_NEXT_OPCODE();
25002         }
25003 
25004         /* here we are sure we are dealing with an object */
25005 
25006         if (0) {
25007                 MAKE_REAL_ZVAL_PTR(property);
25008         }
25009 
25010         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
25011                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25012                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
25013                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
25014 
25015                         have_get_ptr = 1;
25016                         incdec_op(*zptr);
25017                         if (RETURN_VALUE_USED(opline)) {
25018                                 *retval = *zptr;
25019                                 PZVAL_LOCK(*retval);
25020                         }
25021                 }
25022         }
25023 
25024         if (!have_get_ptr) {
25025                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
25026                         zval *z;
25027 
25028                         Z_ADDREF_P(object);
25029                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25030 
25031                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
25032                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
25033 
25034                                 if (Z_REFCOUNT_P(z) == 0) {
25035                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
25036                                         zval_dtor(z);
25037                                         FREE_ZVAL(z);
25038                                 }
25039                                 z = value;
25040                         }
25041                         Z_ADDREF_P(z);
25042                         SEPARATE_ZVAL_IF_NOT_REF(&z);
25043                         incdec_op(z);
25044                         *retval = z;
25045                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25046                         zval_ptr_dtor(&object);
25047                         SELECTIVE_PZVAL_LOCK(*retval, opline);
25048                         zval_ptr_dtor(&z);
25049                 } else {
25050                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25051                         if (RETURN_VALUE_USED(opline)) {
25052                                 PZVAL_LOCK(&EG(uninitialized_zval));
25053                                 *retval = &EG(uninitialized_zval);
25054                         }
25055                 }
25056         }
25057 
25058         if (0) {
25059                 zval_ptr_dtor(&property);
25060         } else {
25061 
25062         }
25063 
25064         CHECK_EXCEPTION();
25065         ZEND_VM_NEXT_OPCODE();
25066 }
25067 
25068 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25069 {
25070         return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25071 }
25072 
25073 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25074 {
25075         return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25076 }
25077 
25078 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
25079 {
25080         USE_OPLINE
25081 
25082         zval **object_ptr;
25083         zval *object;
25084         zval *property;
25085         zval *retval;
25086         int have_get_ptr = 0;
25087 
25088         SAVE_OPLINE();
25089         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25090         property = opline->op2.zv;
25091         retval = &EX_T(opline->result.var).tmp_var;
25092 
25093         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
25094                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
25095         }
25096 
25097         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
25098         object = *object_ptr;
25099 
25100         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
25101                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25102 
25103                 ZVAL_NULL(retval);
25104 
25105                 CHECK_EXCEPTION();
25106                 ZEND_VM_NEXT_OPCODE();
25107         }
25108 
25109         /* here we are sure we are dealing with an object */
25110 
25111         if (0) {
25112                 MAKE_REAL_ZVAL_PTR(property);
25113         }
25114 
25115         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
25116                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25117                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
25118                         have_get_ptr = 1;
25119                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
25120 
25121                         ZVAL_COPY_VALUE(retval, *zptr);
25122                         zendi_zval_copy_ctor(*retval);
25123 
25124                         incdec_op(*zptr);
25125 
25126                 }
25127         }
25128 
25129         if (!have_get_ptr) {
25130                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
25131                         zval *z, *z_copy;
25132 
25133                         Z_ADDREF_P(object);
25134                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25135                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
25136                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
25137 
25138                                 if (Z_REFCOUNT_P(z) == 0) {
25139                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
25140                                         zval_dtor(z);
25141                                         FREE_ZVAL(z);
25142                                 }
25143                                 z = value;
25144                         }
25145                         ZVAL_COPY_VALUE(retval, z);
25146                         zendi_zval_copy_ctor(*retval);
25147                         ALLOC_ZVAL(z_copy);
25148                         INIT_PZVAL_COPY(z_copy, z);
25149                         zendi_zval_copy_ctor(*z_copy);
25150                         incdec_op(z_copy);
25151                         Z_ADDREF_P(z);
25152                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25153                         zval_ptr_dtor(&object);
25154                         zval_ptr_dtor(&z_copy);
25155                         zval_ptr_dtor(&z);
25156                 } else {
25157                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
25158                         ZVAL_NULL(retval);
25159                 }
25160         }
25161 
25162         if (0) {
25163                 zval_ptr_dtor(&property);
25164         } else {
25165 
25166         }
25167 
25168         CHECK_EXCEPTION();
25169         ZEND_VM_NEXT_OPCODE();
25170 }
25171 
25172 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25173 {
25174         return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25175 }
25176 
25177 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25178 {
25179         return zend_post_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25180 }
25181 
25182 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS)
25183 {
25184         USE_OPLINE
25185 
25186         zval *container;
25187 
25188         zval *offset;
25189 
25190         SAVE_OPLINE();
25191         container = _get_obj_zval_ptr_unused(TSRMLS_C);
25192         offset  = opline->op2.zv;
25193 
25194         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
25195             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
25196                 zend_error(E_NOTICE, "Trying to get property of non-object");
25197                 PZVAL_LOCK(&EG(uninitialized_zval));
25198                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
25199 
25200         } else {
25201                 zval *retval;
25202 
25203                 if (0) {
25204                         MAKE_REAL_ZVAL_PTR(offset);
25205                 }
25206 
25207                 /* here we are sure we are dealing with an object */
25208                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25209 
25210                 PZVAL_LOCK(retval);
25211                 EX_T(opline->result.var).var.ptr = retval;
25212 
25213                 if (0) {
25214                         zval_ptr_dtor(&offset);
25215                 } else {
25216 
25217                 }
25218         }
25219 
25220         CHECK_EXCEPTION();
25221         ZEND_VM_NEXT_OPCODE();
25222 }
25223 
25224 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25225 {
25226         return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25227 }
25228 
25229 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25230 {
25231         USE_OPLINE
25232         zend_free_op free_op1;
25233         zval *property;
25234         zval **container;
25235 
25236         SAVE_OPLINE();
25237         property = opline->op2.zv;
25238 
25239         if (0) {
25240                 MAKE_REAL_ZVAL_PTR(property);
25241         }
25242         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25243         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
25244                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25245         }
25246 
25247         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
25248         if (0) {
25249                 zval_ptr_dtor(&property);
25250         } else {
25251 
25252         }
25253         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
25254                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
25255         }
25256 
25257         /* We are going to assign the result by reference */
25258         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
25259                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
25260 
25261                 Z_DELREF_PP(retval_ptr);
25262                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
25263                 Z_ADDREF_PP(retval_ptr);
25264                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
25265                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
25266         }
25267 
25268         CHECK_EXCEPTION();
25269         ZEND_VM_NEXT_OPCODE();
25270 }
25271 
25272 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25273 {
25274         USE_OPLINE
25275         zend_free_op free_op1;
25276         zval *property;
25277         zval **container;
25278 
25279         SAVE_OPLINE();
25280         property = opline->op2.zv;
25281         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25282 
25283         if (0) {
25284                 MAKE_REAL_ZVAL_PTR(property);
25285         }
25286         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
25287                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25288         }
25289         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
25290         if (0) {
25291                 zval_ptr_dtor(&property);
25292         } else {
25293 
25294         }
25295         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
25296                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
25297         }
25298 
25299         CHECK_EXCEPTION();
25300         ZEND_VM_NEXT_OPCODE();
25301 }
25302 
25303 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25304 {
25305         USE_OPLINE
25306 
25307         zval *container;
25308 
25309         zval *offset;
25310 
25311         SAVE_OPLINE();
25312         container = _get_obj_zval_ptr_unused(TSRMLS_C);
25313         offset  = opline->op2.zv;
25314 
25315         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
25316             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
25317                 PZVAL_LOCK(&EG(uninitialized_zval));
25318                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
25319 
25320         } else {
25321                 zval *retval;
25322 
25323                 if (0) {
25324                         MAKE_REAL_ZVAL_PTR(offset);
25325                 }
25326 
25327                 /* here we are sure we are dealing with an object */
25328                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25329 
25330                 PZVAL_LOCK(retval);
25331                 EX_T(opline->result.var).var.ptr = retval;
25332 
25333                 if (0) {
25334                         zval_ptr_dtor(&offset);
25335                 } else {
25336 
25337                 }
25338         }
25339 
25340         CHECK_EXCEPTION();
25341         ZEND_VM_NEXT_OPCODE();
25342 }
25343 
25344 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25345 {
25346         USE_OPLINE
25347 
25348         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
25349                 /* Behave like FETCH_OBJ_W */
25350                 zend_free_op free_op1;
25351                 zval *property;
25352                 zval **container;
25353 
25354                 SAVE_OPLINE();
25355                 property = opline->op2.zv;
25356                 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25357 
25358                 if (0) {
25359                         MAKE_REAL_ZVAL_PTR(property);
25360                 }
25361                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
25362                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25363                 }
25364                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
25365                 if (0) {
25366                         zval_ptr_dtor(&property);
25367                 } else {
25368 
25369                 }
25370                 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
25371                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
25372                 }
25373 
25374                 CHECK_EXCEPTION();
25375                 ZEND_VM_NEXT_OPCODE();
25376         } else {
25377                 return zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25378         }
25379 }
25380 
25381 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25382 {
25383         USE_OPLINE
25384         zend_free_op free_op1, free_res;
25385         zval **container;
25386         zval *property;
25387 
25388         SAVE_OPLINE();
25389         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25390         property = opline->op2.zv;
25391 
25392         if (IS_UNUSED == IS_CV) {
25393                 if (container != &EG(uninitialized_zval_ptr)) {
25394                         SEPARATE_ZVAL_IF_NOT_REF(container);
25395                 }
25396         }
25397         if (0) {
25398                 MAKE_REAL_ZVAL_PTR(property);
25399         }
25400         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
25401                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
25402         }
25403         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
25404         if (0) {
25405                 zval_ptr_dtor(&property);
25406         } else {
25407 
25408         }
25409         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
25410                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
25411         }
25412 
25413         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
25414         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
25415                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
25416         }
25417         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
25418         FREE_OP_VAR_PTR(free_res);
25419         CHECK_EXCEPTION();
25420         ZEND_VM_NEXT_OPCODE();
25421 }
25422 
25423 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25424 {
25425         USE_OPLINE
25426 
25427         zval **object_ptr;
25428         zval *property_name;
25429 
25430         SAVE_OPLINE();
25431         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25432         property_name = opline->op2.zv;
25433 
25434         if (0) {
25435                 MAKE_REAL_ZVAL_PTR(property_name);
25436         }
25437         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
25438                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
25439         }
25440         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25441         if (0) {
25442                 zval_ptr_dtor(&property_name);
25443         } else {
25444 
25445         }
25446 
25447         /* assign_obj has two opcodes! */
25448         CHECK_EXCEPTION();
25449         ZEND_VM_INC_OPCODE();
25450         ZEND_VM_NEXT_OPCODE();
25451 }
25452 
25453 static int ZEND_FASTCALL  ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25454 {
25455         USE_OPLINE
25456         zval *str = &EX_T(opline->result.var).tmp_var;
25457 
25458         SAVE_OPLINE();
25459 
25460         if (IS_UNUSED == IS_UNUSED) {
25461                 /* Initialize for erealloc in add_char_to_string */
25462                 Z_STRVAL_P(str) = NULL;
25463                 Z_STRLEN_P(str) = 0;
25464                 Z_TYPE_P(str) = IS_STRING;
25465 
25466                 INIT_PZVAL(str);
25467         }
25468 
25469         add_char_to_string(str, str, opline->op2.zv);
25470 
25471         /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
25472         /*CHECK_EXCEPTION();*/
25473         ZEND_VM_NEXT_OPCODE();
25474 }
25475 
25476 static int ZEND_FASTCALL  ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25477 {
25478         USE_OPLINE
25479         zval *str = &EX_T(opline->result.var).tmp_var;
25480 
25481         SAVE_OPLINE();
25482 
25483         if (IS_UNUSED == IS_UNUSED) {
25484                 /* Initialize for erealloc in add_string_to_string */
25485                 Z_STRVAL_P(str) = NULL;
25486                 Z_STRLEN_P(str) = 0;
25487                 Z_TYPE_P(str) = IS_STRING;
25488 
25489                 INIT_PZVAL(str);
25490         }
25491 
25492         add_string_to_string(str, str, opline->op2.zv);
25493 
25494         /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
25495         /*CHECK_EXCEPTION();*/
25496         ZEND_VM_NEXT_OPCODE();
25497 }
25498 
25499 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25500 {
25501         USE_OPLINE
25502         zval *function_name;
25503         char *function_name_strval;
25504         int function_name_strlen;
25505 
25506         call_slot *call = EX(call_slots) + opline->result.num;
25507 
25508         SAVE_OPLINE();
25509 
25510         function_name = opline->op2.zv;
25511 
25512         if (IS_CONST != IS_CONST &&
25513             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
25514                 if (UNEXPECTED(EG(exception) != NULL)) {
25515                         HANDLE_EXCEPTION();
25516                 }
25517                 zend_error_noreturn(E_ERROR, "Method name must be a string");
25518         }
25519 
25520         function_name_strval = Z_STRVAL_P(function_name);
25521         function_name_strlen = Z_STRLEN_P(function_name);
25522 
25523         call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
25524 
25525         if (EXPECTED(call->object != NULL) &&
25526             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
25527                 call->called_scope = Z_OBJCE_P(call->object);
25528 
25529                 if (IS_CONST != IS_CONST ||
25530                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
25531                     zval *object = call->object;
25532 
25533                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
25534                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
25535                         }
25536 
25537                         /* First, locate the function. */
25538                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
25539                         if (UNEXPECTED(call->fbc == NULL)) {
25540                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
25541                         }
25542                         if (IS_CONST == IS_CONST &&
25543                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
25544                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
25545                             EXPECTED(call->object == object)) {
25546                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
25547                         }
25548                 }
25549         } else {
25550                 if (UNEXPECTED(EG(exception) != NULL)) {
25551 
25552                         HANDLE_EXCEPTION();
25553                 }
25554                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
25555         }
25556 
25557         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
25558                 call->object = NULL;
25559         } else {
25560                 if (!PZVAL_IS_REF(call->object)) {
25561                         Z_ADDREF_P(call->object); /* For $this pointer */
25562                 } else {
25563                         zval *this_ptr;
25564                         ALLOC_ZVAL(this_ptr);
25565                         INIT_PZVAL_COPY(this_ptr, call->object);
25566                         zval_copy_ctor(this_ptr);
25567                         call->object = this_ptr;
25568                 }
25569         }
25570 
25571         call->num_additional_args = 0;
25572         call->is_ctor_call = 0;
25573         EX(call) = call;
25574 
25575 
25576         CHECK_EXCEPTION();
25577         ZEND_VM_NEXT_OPCODE();
25578 }
25579 
25580 static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25581 {
25582         USE_OPLINE
25583 
25584         SAVE_OPLINE();
25585         if (IS_UNUSED == IS_UNUSED) {
25586                 zend_constant *c;
25587                 zval *retval;
25588 
25589                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
25590                         c = CACHED_PTR(opline->op2.literal->cache_slot);
25591                 } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
25592                         if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
25593                                 char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
25594                                 if(!actual) {
25595                                         actual = Z_STRVAL_P(opline->op2.zv);
25596                                 } else {
25597                                         actual++;
25598                                 }
25599                                 /* non-qualified constant - allow text substitution */
25600                                 zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
25601                                 ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
25602                                 CHECK_EXCEPTION();
25603                                 ZEND_VM_NEXT_OPCODE();
25604                         } else {
25605                                 zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
25606                         }
25607                 } else {
25608                         CACHE_PTR(opline->op2.literal->cache_slot, c);
25609                 }
25610                 retval = &EX_T(opline->result.var).tmp_var;
25611                 ZVAL_COPY_VALUE(retval, &c->value);
25612                 zval_copy_ctor(retval);
25613         } else {
25614                 /* class constant */
25615                 zend_class_entry *ce;
25616                 zval **value;
25617 
25618                 if (IS_UNUSED == IS_CONST) {
25619                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
25620                                 value = CACHED_PTR(opline->op2.literal->cache_slot);
25621                                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
25622                                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
25623                                 goto constant_fetch_end;
25624                         } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
25625                                 ce = CACHED_PTR(opline->op1.literal->cache_slot);
25626                         } else {
25627                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
25628                                 if (UNEXPECTED(EG(exception) != NULL)) {
25629                                         HANDLE_EXCEPTION();
25630                                 }
25631                                 if (UNEXPECTED(ce == NULL)) {
25632                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
25633                                 }
25634                                 CACHE_PTR(opline->op1.literal->cache_slot, ce);
25635                         }
25636                 } else {
25637                         ce = EX_T(opline->op1.var).class_entry;
25638                         if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
25639                                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
25640                                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
25641                                 goto constant_fetch_end;
25642                         }
25643                 }
25644 
25645                 if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
25646                         if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
25647                                 zend_class_entry *old_scope = EG(scope);
25648 
25649                                 EG(scope) = ce;
25650                                 zval_update_constant(value, 1 TSRMLS_CC);
25651                                 EG(scope) = old_scope;
25652                         }
25653                         if (IS_UNUSED == IS_CONST) {
25654                                 CACHE_PTR(opline->op2.literal->cache_slot, value);
25655                         } else {
25656                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
25657                         }
25658                         ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
25659                         zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
25660                 } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
25661                         /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
25662                         ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
25663                 } else {
25664                         zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
25665                 }
25666         }
25667 constant_fetch_end:
25668         CHECK_EXCEPTION();
25669         ZEND_VM_NEXT_OPCODE();
25670 }
25671 
25672 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25673 {
25674         USE_OPLINE
25675 
25676         array_init(&EX_T(opline->result.var).tmp_var);
25677         if (IS_UNUSED == IS_UNUSED) {
25678                 ZEND_VM_NEXT_OPCODE();
25679 #if 0 || IS_UNUSED != IS_UNUSED
25680         } else {
25681                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25682 #endif
25683         }
25684 }
25685 
25686 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25687 {
25688         USE_OPLINE
25689 
25690         zval **container;
25691         zval *offset;
25692         ulong hval;
25693 
25694         SAVE_OPLINE();
25695         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25696         if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
25697                 SEPARATE_ZVAL_IF_NOT_REF(container);
25698         }
25699         offset = opline->op2.zv;
25700 
25701         if (IS_UNUSED != IS_VAR || container) {
25702                 switch (Z_TYPE_PP(container)) {
25703                         case IS_ARRAY: {
25704                                 HashTable *ht = Z_ARRVAL_PP(container);
25705 
25706                                 switch (Z_TYPE_P(offset)) {
25707                                         case IS_DOUBLE:
25708                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
25709                                                 zend_hash_index_del(ht, hval);
25710                                                 break;
25711                                         case IS_RESOURCE:
25712                                         case IS_BOOL:
25713                                         case IS_LONG:
25714                                                 hval = Z_LVAL_P(offset);
25715                                                 zend_hash_index_del(ht, hval);
25716                                                 break;
25717                                         case IS_STRING:
25718                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
25719                                                         Z_ADDREF_P(offset);
25720                                                 }
25721                                                 if (IS_CONST == IS_CONST) {
25722                                                         hval = Z_HASH_P(offset);
25723                                                 } else {
25724                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
25725                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
25726                                                 }
25727                                                 if (ht == &EG(symbol_table)) {
25728                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
25729                                                 } else {
25730                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
25731                                                 }
25732                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
25733                                                         zval_ptr_dtor(&offset);
25734                                                 }
25735                                                 break;
25736 num_index_dim:
25737                                                 zend_hash_index_del(ht, hval);
25738                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
25739                                                         zval_ptr_dtor(&offset);
25740                                                 }
25741                                                 break;
25742                                         case IS_NULL:
25743                                                 zend_hash_del(ht, "", sizeof(""));
25744                                                 break;
25745                                         default:
25746                                                 zend_error(E_WARNING, "Illegal offset type in unset");
25747                                                 break;
25748                                 }
25749 
25750                                 break;
25751                         }
25752                         case IS_OBJECT:
25753                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
25754                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
25755                                 }
25756                                 if (0) {
25757                                         MAKE_REAL_ZVAL_PTR(offset);
25758                                 }
25759                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
25760                                 if (0) {
25761                                         zval_ptr_dtor(&offset);
25762                                 } else {
25763 
25764                                 }
25765                                 break;
25766                         case IS_STRING:
25767                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
25768                                 ZEND_VM_CONTINUE(); /* bailed out before */
25769                         default:
25770 
25771                                 break;
25772                 }
25773         } else {
25774 
25775         }
25776 
25777         CHECK_EXCEPTION();
25778         ZEND_VM_NEXT_OPCODE();
25779 }
25780 
25781 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25782 {
25783         USE_OPLINE
25784 
25785         zval **container;
25786         zval *offset;
25787 
25788         SAVE_OPLINE();
25789         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
25790         offset = opline->op2.zv;
25791 
25792         if (IS_UNUSED != IS_VAR || container) {
25793                 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
25794                         SEPARATE_ZVAL_IF_NOT_REF(container);
25795                 }
25796                 if (Z_TYPE_PP(container) == IS_OBJECT) {
25797                         if (0) {
25798                                 MAKE_REAL_ZVAL_PTR(offset);
25799                         }
25800                         if (Z_OBJ_HT_P(*container)->unset_property) {
25801                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25802                         } else {
25803                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
25804                         }
25805                         if (0) {
25806                                 zval_ptr_dtor(&offset);
25807                         } else {
25808 
25809                         }
25810                 } else {
25811 
25812                 }
25813         } else {
25814 
25815         }
25816 
25817         CHECK_EXCEPTION();
25818         ZEND_VM_NEXT_OPCODE();
25819 }
25820 
25821 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
25822 {
25823         USE_OPLINE
25824 
25825         zval *container;
25826         zval **value = NULL;
25827         int result = 0;
25828         ulong hval;
25829         zval *offset;
25830 
25831         SAVE_OPLINE();
25832         container = _get_obj_zval_ptr_unused(TSRMLS_C);
25833         offset = opline->op2.zv;
25834 
25835         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
25836                 HashTable *ht;
25837                 int isset = 0;
25838 
25839                 ht = Z_ARRVAL_P(container);
25840 
25841                 switch (Z_TYPE_P(offset)) {
25842                         case IS_DOUBLE:
25843                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
25844                                 goto num_index_prop;
25845                         case IS_RESOURCE:
25846                         case IS_BOOL:
25847                         case IS_LONG:
25848                                 hval = Z_LVAL_P(offset);
25849 num_index_prop:
25850                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
25851                                         isset = 1;
25852                                 }
25853                                 break;
25854                         case IS_STRING:
25855                                 if (IS_CONST == IS_CONST) {
25856                                         hval = Z_HASH_P(offset);
25857                                 } else {
25858                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
25859                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
25860                                 }
25861                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
25862                                         isset = 1;
25863                                 }
25864                                 break;
25865                         case IS_NULL:
25866                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
25867                                         isset = 1;
25868                                 }
25869                                 break;
25870                         default:
25871                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
25872                                 break;
25873                 }
25874 
25875                 if (opline->extended_value & ZEND_ISSET) {
25876                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
25877                                 result = 0;
25878                         } else {
25879                                 result = isset;
25880                         }
25881                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
25882                         if (!isset || !i_zend_is_true(*value)) {
25883                                 result = 0;
25884                         } else {
25885                                 result = 1;
25886                         }
25887                 }
25888 
25889         } else if (Z_TYPE_P(container) == IS_OBJECT) {
25890                 if (0) {
25891                         MAKE_REAL_ZVAL_PTR(offset);
25892                 }
25893                 if (prop_dim) {
25894                         if (Z_OBJ_HT_P(container)->has_property) {
25895                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
25896                         } else {
25897                                 zend_error(E_NOTICE, "Trying to check property of non-object");
25898                                 result = 0;
25899                         }
25900                 } else {
25901                         if (Z_OBJ_HT_P(container)->has_dimension) {
25902                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
25903                         } else {
25904                                 zend_error(E_NOTICE, "Trying to check element of non-array");
25905                                 result = 0;
25906                         }
25907                 }
25908                 if (0) {
25909                         zval_ptr_dtor(&offset);
25910                 } else {
25911 
25912                 }
25913         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
25914                 zval tmp;
25915 
25916                 if (Z_TYPE_P(offset) != IS_LONG) {
25917                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
25918                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
25919                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
25920                                 ZVAL_COPY_VALUE(&tmp, offset);
25921                                 zval_copy_ctor(&tmp);
25922                                 convert_to_long(&tmp);
25923                                 offset = &tmp;
25924                         } else {
25925                                 /* can not be converted to proper offset, return "not set" */
25926                                 result = 0;
25927                         }
25928                 }
25929                 if (Z_TYPE_P(offset) == IS_LONG) {
25930                         if (opline->extended_value & ZEND_ISSET) {
25931                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
25932                                         result = 1;
25933                                 }
25934                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
25935                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
25936                                         result = 1;
25937                                 }
25938                         }
25939                 }
25940 
25941         } else {
25942 
25943         }
25944 
25945         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
25946         if (opline->extended_value & ZEND_ISSET) {
25947                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
25948         } else {
25949                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
25950         }
25951 
25952         CHECK_EXCEPTION();
25953         ZEND_VM_NEXT_OPCODE();
25954 }
25955 
25956 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25957 {
25958         return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25959 }
25960 
25961 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25962 {
25963         return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
25964 }
25965 
25966 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25967 {
25968         USE_OPLINE
25969 
25970         /* The generator object is stored in return_value_ptr_ptr */
25971         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
25972 
25973         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
25974                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
25975         }
25976 
25977         /* Destroy the previously yielded value */
25978         if (generator->value) {
25979                 zval_ptr_dtor(&generator->value);
25980         }
25981 
25982         /* Destroy the previously yielded key */
25983         if (generator->key) {
25984                 zval_ptr_dtor(&generator->key);
25985         }
25986 
25987         /* Set the new yielded value */
25988         if (IS_UNUSED != IS_UNUSED) {
25989 
25990 
25991                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
25992                         /* Constants and temporary variables aren't yieldable by reference,
25993                          * but we still allow them with a notice. */
25994                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
25995                                 zval *value, *copy;
25996 
25997                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
25998 
25999                                 value = NULL;
26000                                 ALLOC_ZVAL(copy);
26001                                 INIT_PZVAL_COPY(copy, value);
26002 
26003                                 /* Temporary variables don't need ctor copying */
26004                                 if (!0) {
26005                                         zval_copy_ctor(copy);
26006                                 }
26007 
26008                                 generator->value = copy;
26009                         } else {
26010                                 zval **value_ptr = NULL;
26011 
26012                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
26013                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
26014                                 }
26015 
26016                                 /* If a function call result is yielded and the function did
26017                                  * not return by reference we throw a notice. */
26018                                 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
26019                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
26020                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
26021                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
26022                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26023 
26024                                         Z_ADDREF_PP(value_ptr);
26025                                         generator->value = *value_ptr;
26026                                 } else {
26027                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
26028                                         Z_ADDREF_PP(value_ptr);
26029                                         generator->value = *value_ptr;
26030                                 }
26031 
26032                         }
26033                 } else {
26034                         zval *value = NULL;
26035 
26036                         /* Consts, temporary variables and references need copying */
26037                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
26038                                 || PZVAL_IS_REF(value)
26039                         ) {
26040                                 zval *copy;
26041 
26042                                 ALLOC_ZVAL(copy);
26043                                 INIT_PZVAL_COPY(copy, value);
26044 
26045                                 /* Temporary variables don't need ctor copying */
26046                                 if (!0) {
26047                                         zval_copy_ctor(copy);
26048                                 }
26049 
26050                                 generator->value = copy;
26051 
26052                         } else {
26053                                 if (IS_UNUSED == IS_CV) {
26054                                         Z_ADDREF_P(value);
26055                                 }
26056                                 generator->value = value;
26057                         }
26058                 }
26059         } else {
26060                 /* If no value was specified yield null */
26061                 Z_ADDREF(EG(uninitialized_zval));
26062                 generator->value = &EG(uninitialized_zval);
26063         }
26064 
26065         /* Set the new yielded key */
26066         if (IS_CONST != IS_UNUSED) {
26067 
26068                 zval *key = opline->op2.zv;
26069 
26070                 /* Consts, temporary variables and references need copying */
26071                 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
26072                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
26073                 ) {
26074                         zval *copy;
26075 
26076                         ALLOC_ZVAL(copy);
26077                         INIT_PZVAL_COPY(copy, key);
26078 
26079                         /* Temporary variables don't need ctor copying */
26080                         if (!0) {
26081                                 zval_copy_ctor(copy);
26082                         }
26083 
26084                         generator->key = copy;
26085                 } else {
26086                         Z_ADDREF_P(key);
26087                         generator->key = key;
26088                 }
26089 
26090                 if (Z_TYPE_P(generator->key) == IS_LONG
26091                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
26092                 ) {
26093                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
26094                 }
26095 
26096         } else {
26097                 /* If no key was specified we use auto-increment keys */
26098                 generator->largest_used_integer_key++;
26099 
26100                 ALLOC_INIT_ZVAL(generator->key);
26101                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
26102         }
26103 
26104         if (RETURN_VALUE_USED(opline)) {
26105                 /* If the return value of yield is used set the send
26106                  * target and initialize it to NULL */
26107                 generator->send_target = &EX_T(opline->result.var).var.ptr;
26108                 Z_ADDREF(EG(uninitialized_zval));
26109                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26110         } else {
26111                 generator->send_target = NULL;
26112         }
26113 
26114         /* We increment to the next op, so we are at the correct position when the
26115          * generator is resumed. */
26116         ZEND_VM_INC_OPCODE();
26117 
26118         /* The GOTO VM uses a local opline variable. We need to set the opline
26119          * variable in execute_data so we don't resume at an old position. */
26120         SAVE_OPLINE();
26121 
26122         ZEND_VM_RETURN();
26123 }
26124 
26125 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26126 {
26127         return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26128 }
26129 
26130 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
26131 {
26132         USE_OPLINE
26133         zend_free_op free_op2, free_op_data1;
26134         zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26135         zval *object;
26136         zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26137         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
26138         int have_get_ptr = 0;
26139 
26140         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
26141                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26142         }
26143 
26144         make_real_object(object_ptr TSRMLS_CC);
26145         object = *object_ptr;
26146 
26147         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26148                 zend_error(E_WARNING, "Attempt to assign property of non-object");
26149                 zval_dtor(free_op2.var);
26150                 FREE_OP(free_op_data1);
26151 
26152                 if (RETURN_VALUE_USED(opline)) {
26153                         PZVAL_LOCK(&EG(uninitialized_zval));
26154                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26155                 }
26156         } else {
26157                 /* here we are sure we are dealing with an object */
26158                 if (1) {
26159                         MAKE_REAL_ZVAL_PTR(property);
26160                 }
26161 
26162                 /* here property is a string */
26163                 if (opline->extended_value == ZEND_ASSIGN_OBJ
26164                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26165                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26166                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
26167                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
26168 
26169                                 have_get_ptr = 1;
26170                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
26171                                 if (RETURN_VALUE_USED(opline)) {
26172                                         PZVAL_LOCK(*zptr);
26173                                         EX_T(opline->result.var).var.ptr = *zptr;
26174                                 }
26175                         }
26176                 }
26177 
26178                 if (!have_get_ptr) {
26179                         zval *z = NULL;
26180 
26181                         Z_ADDREF_P(object);
26182                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
26183                                 if (Z_OBJ_HT_P(object)->read_property) {
26184                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26185                                 }
26186                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
26187                                 if (Z_OBJ_HT_P(object)->read_dimension) {
26188                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
26189                                 }
26190                         }
26191                         if (z) {
26192                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
26193                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26194 
26195                                         if (Z_REFCOUNT_P(z) == 0) {
26196                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
26197                                                 zval_dtor(z);
26198                                                 FREE_ZVAL(z);
26199                                         }
26200                                         z = value;
26201                                 }
26202                                 Z_ADDREF_P(z);
26203                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
26204                                 binary_op(z, z, value TSRMLS_CC);
26205                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
26206                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26207                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
26208                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
26209                                 }
26210                                 if (RETURN_VALUE_USED(opline)) {
26211                                         PZVAL_LOCK(z);
26212                                         EX_T(opline->result.var).var.ptr = z;
26213                                 }
26214                                 zval_ptr_dtor(&z);
26215                         } else {
26216                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
26217                                 if (RETURN_VALUE_USED(opline)) {
26218                                         PZVAL_LOCK(&EG(uninitialized_zval));
26219                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26220                                 }
26221                         }
26222                         zval_ptr_dtor(&object);
26223                 }
26224 
26225                 if (1) {
26226                         zval_ptr_dtor(&property);
26227                 } else {
26228                         zval_dtor(free_op2.var);
26229                 }
26230                 FREE_OP(free_op_data1);
26231         }
26232 
26233         /* assign_obj has two opcodes! */
26234         CHECK_EXCEPTION();
26235         ZEND_VM_INC_OPCODE();
26236         ZEND_VM_NEXT_OPCODE();
26237 }
26238 
26239 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
26240 {
26241         USE_OPLINE
26242         zend_free_op free_op2, free_op_data2, free_op_data1;
26243         zval **var_ptr;
26244         zval *value;
26245 
26246         SAVE_OPLINE();
26247         switch (opline->extended_value) {
26248                 case ZEND_ASSIGN_OBJ:
26249                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26250                         break;
26251                 case ZEND_ASSIGN_DIM: {
26252                                 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26253 
26254                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26255                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26256                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
26257                                         if (IS_UNUSED == IS_VAR && !0) {
26258                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
26259                                         }
26260                                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26261                                 } else {
26262                                         zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26263 
26264                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
26265                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
26266                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
26267                                 }
26268                         }
26269                         break;
26270                 default:
26271                         value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26272                         var_ptr = NULL;
26273                         /* do nothing */
26274                         break;
26275         }
26276 
26277         if (UNEXPECTED(var_ptr == NULL)) {
26278                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
26279         }
26280 
26281         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
26282                 if (RETURN_VALUE_USED(opline)) {
26283                         PZVAL_LOCK(&EG(uninitialized_zval));
26284                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26285                 }
26286                 zval_dtor(free_op2.var);
26287 
26288                 CHECK_EXCEPTION();
26289                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
26290                         ZEND_VM_INC_OPCODE();
26291                 }
26292                 ZEND_VM_NEXT_OPCODE();
26293         }
26294 
26295         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
26296 
26297         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
26298            && Z_OBJ_HANDLER_PP(var_ptr, get)
26299            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
26300                 /* proxy object */
26301                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
26302                 Z_ADDREF_P(objval);
26303                 binary_op(objval, objval, value TSRMLS_CC);
26304                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
26305                 zval_ptr_dtor(&objval);
26306         } else {
26307                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
26308         }
26309 
26310         if (RETURN_VALUE_USED(opline)) {
26311                 PZVAL_LOCK(*var_ptr);
26312                 EX_T(opline->result.var).var.ptr = *var_ptr;
26313         }
26314         zval_dtor(free_op2.var);
26315 
26316         if (opline->extended_value == ZEND_ASSIGN_DIM) {
26317                 FREE_OP(free_op_data1);
26318                 FREE_OP_VAR_PTR(free_op_data2);
26319 
26320                 CHECK_EXCEPTION();
26321                 ZEND_VM_INC_OPCODE();
26322         } else {
26323 
26324                 CHECK_EXCEPTION();
26325         }
26326         ZEND_VM_NEXT_OPCODE();
26327 }
26328 
26329 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26330 {
26331         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26332 }
26333 
26334 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26335 {
26336         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26337 }
26338 
26339 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26340 {
26341         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26342 }
26343 
26344 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26345 {
26346         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26347 }
26348 
26349 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26350 {
26351         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26352 }
26353 
26354 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26355 {
26356         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26357 }
26358 
26359 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26360 {
26361         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26362 }
26363 
26364 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26365 {
26366         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26367 }
26368 
26369 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26370 {
26371         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26372 }
26373 
26374 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26375 {
26376         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26377 }
26378 
26379 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26380 {
26381         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26382 }
26383 
26384 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
26385 {
26386         USE_OPLINE
26387         zend_free_op free_op2;
26388         zval **object_ptr;
26389         zval *object;
26390         zval *property;
26391         zval **retval;
26392         int have_get_ptr = 0;
26393 
26394         SAVE_OPLINE();
26395         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26396         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26397         retval = &EX_T(opline->result.var).var.ptr;
26398 
26399         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
26400                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
26401         }
26402 
26403         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
26404         object = *object_ptr;
26405 
26406         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26407                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26408                 zval_dtor(free_op2.var);
26409                 if (RETURN_VALUE_USED(opline)) {
26410                         PZVAL_LOCK(&EG(uninitialized_zval));
26411                         *retval = &EG(uninitialized_zval);
26412                 }
26413 
26414                 CHECK_EXCEPTION();
26415                 ZEND_VM_NEXT_OPCODE();
26416         }
26417 
26418         /* here we are sure we are dealing with an object */
26419 
26420         if (1) {
26421                 MAKE_REAL_ZVAL_PTR(property);
26422         }
26423 
26424         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26425                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26426                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
26427                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
26428 
26429                         have_get_ptr = 1;
26430                         incdec_op(*zptr);
26431                         if (RETURN_VALUE_USED(opline)) {
26432                                 *retval = *zptr;
26433                                 PZVAL_LOCK(*retval);
26434                         }
26435                 }
26436         }
26437 
26438         if (!have_get_ptr) {
26439                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
26440                         zval *z;
26441 
26442                         Z_ADDREF_P(object);
26443                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26444 
26445                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
26446                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26447 
26448                                 if (Z_REFCOUNT_P(z) == 0) {
26449                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
26450                                         zval_dtor(z);
26451                                         FREE_ZVAL(z);
26452                                 }
26453                                 z = value;
26454                         }
26455                         Z_ADDREF_P(z);
26456                         SEPARATE_ZVAL_IF_NOT_REF(&z);
26457                         incdec_op(z);
26458                         *retval = z;
26459                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26460                         zval_ptr_dtor(&object);
26461                         SELECTIVE_PZVAL_LOCK(*retval, opline);
26462                         zval_ptr_dtor(&z);
26463                 } else {
26464                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26465                         if (RETURN_VALUE_USED(opline)) {
26466                                 PZVAL_LOCK(&EG(uninitialized_zval));
26467                                 *retval = &EG(uninitialized_zval);
26468                         }
26469                 }
26470         }
26471 
26472         if (1) {
26473                 zval_ptr_dtor(&property);
26474         } else {
26475                 zval_dtor(free_op2.var);
26476         }
26477 
26478         CHECK_EXCEPTION();
26479         ZEND_VM_NEXT_OPCODE();
26480 }
26481 
26482 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26483 {
26484         return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26485 }
26486 
26487 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26488 {
26489         return zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26490 }
26491 
26492 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
26493 {
26494         USE_OPLINE
26495         zend_free_op free_op2;
26496         zval **object_ptr;
26497         zval *object;
26498         zval *property;
26499         zval *retval;
26500         int have_get_ptr = 0;
26501 
26502         SAVE_OPLINE();
26503         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26504         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26505         retval = &EX_T(opline->result.var).tmp_var;
26506 
26507         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
26508                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
26509         }
26510 
26511         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
26512         object = *object_ptr;
26513 
26514         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26515                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26516                 zval_dtor(free_op2.var);
26517                 ZVAL_NULL(retval);
26518 
26519                 CHECK_EXCEPTION();
26520                 ZEND_VM_NEXT_OPCODE();
26521         }
26522 
26523         /* here we are sure we are dealing with an object */
26524 
26525         if (1) {
26526                 MAKE_REAL_ZVAL_PTR(property);
26527         }
26528 
26529         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
26530                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26531                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
26532                         have_get_ptr = 1;
26533                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
26534 
26535                         ZVAL_COPY_VALUE(retval, *zptr);
26536                         zendi_zval_copy_ctor(*retval);
26537 
26538                         incdec_op(*zptr);
26539 
26540                 }
26541         }
26542 
26543         if (!have_get_ptr) {
26544                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
26545                         zval *z, *z_copy;
26546 
26547                         Z_ADDREF_P(object);
26548                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26549                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
26550                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
26551 
26552                                 if (Z_REFCOUNT_P(z) == 0) {
26553                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
26554                                         zval_dtor(z);
26555                                         FREE_ZVAL(z);
26556                                 }
26557                                 z = value;
26558                         }
26559                         ZVAL_COPY_VALUE(retval, z);
26560                         zendi_zval_copy_ctor(*retval);
26561                         ALLOC_ZVAL(z_copy);
26562                         INIT_PZVAL_COPY(z_copy, z);
26563                         zendi_zval_copy_ctor(*z_copy);
26564                         incdec_op(z_copy);
26565                         Z_ADDREF_P(z);
26566                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26567                         zval_ptr_dtor(&object);
26568                         zval_ptr_dtor(&z_copy);
26569                         zval_ptr_dtor(&z);
26570                 } else {
26571                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
26572                         ZVAL_NULL(retval);
26573                 }
26574         }
26575 
26576         if (1) {
26577                 zval_ptr_dtor(&property);
26578         } else {
26579                 zval_dtor(free_op2.var);
26580         }
26581 
26582         CHECK_EXCEPTION();
26583         ZEND_VM_NEXT_OPCODE();
26584 }
26585 
26586 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26587 {
26588         return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26589 }
26590 
26591 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26592 {
26593         return zend_post_incdec_property_helper_SPEC_UNUSED_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26594 }
26595 
26596 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS)
26597 {
26598         USE_OPLINE
26599 
26600         zval *container;
26601         zend_free_op free_op2;
26602         zval *offset;
26603 
26604         SAVE_OPLINE();
26605         container = _get_obj_zval_ptr_unused(TSRMLS_C);
26606         offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26607 
26608         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
26609             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
26610                 zend_error(E_NOTICE, "Trying to get property of non-object");
26611                 PZVAL_LOCK(&EG(uninitialized_zval));
26612                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26613                 zval_dtor(free_op2.var);
26614         } else {
26615                 zval *retval;
26616 
26617                 if (1) {
26618                         MAKE_REAL_ZVAL_PTR(offset);
26619                 }
26620 
26621                 /* here we are sure we are dealing with an object */
26622                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26623 
26624                 PZVAL_LOCK(retval);
26625                 EX_T(opline->result.var).var.ptr = retval;
26626 
26627                 if (1) {
26628                         zval_ptr_dtor(&offset);
26629                 } else {
26630                         zval_dtor(free_op2.var);
26631                 }
26632         }
26633 
26634         CHECK_EXCEPTION();
26635         ZEND_VM_NEXT_OPCODE();
26636 }
26637 
26638 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26639 {
26640         return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26641 }
26642 
26643 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26644 {
26645         USE_OPLINE
26646         zend_free_op free_op1, free_op2;
26647         zval *property;
26648         zval **container;
26649 
26650         SAVE_OPLINE();
26651         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26652 
26653         if (1) {
26654                 MAKE_REAL_ZVAL_PTR(property);
26655         }
26656         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26657         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26658                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26659         }
26660 
26661         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
26662         if (1) {
26663                 zval_ptr_dtor(&property);
26664         } else {
26665                 zval_dtor(free_op2.var);
26666         }
26667         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
26668                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
26669         }
26670 
26671         /* We are going to assign the result by reference */
26672         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
26673                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
26674 
26675                 Z_DELREF_PP(retval_ptr);
26676                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
26677                 Z_ADDREF_PP(retval_ptr);
26678                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
26679                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
26680         }
26681 
26682         CHECK_EXCEPTION();
26683         ZEND_VM_NEXT_OPCODE();
26684 }
26685 
26686 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26687 {
26688         USE_OPLINE
26689         zend_free_op free_op1, free_op2;
26690         zval *property;
26691         zval **container;
26692 
26693         SAVE_OPLINE();
26694         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26695         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26696 
26697         if (1) {
26698                 MAKE_REAL_ZVAL_PTR(property);
26699         }
26700         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26701                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26702         }
26703         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
26704         if (1) {
26705                 zval_ptr_dtor(&property);
26706         } else {
26707                 zval_dtor(free_op2.var);
26708         }
26709         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
26710                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
26711         }
26712 
26713         CHECK_EXCEPTION();
26714         ZEND_VM_NEXT_OPCODE();
26715 }
26716 
26717 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26718 {
26719         USE_OPLINE
26720 
26721         zval *container;
26722         zend_free_op free_op2;
26723         zval *offset;
26724 
26725         SAVE_OPLINE();
26726         container = _get_obj_zval_ptr_unused(TSRMLS_C);
26727         offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26728 
26729         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
26730             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
26731                 PZVAL_LOCK(&EG(uninitialized_zval));
26732                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
26733                 zval_dtor(free_op2.var);
26734         } else {
26735                 zval *retval;
26736 
26737                 if (1) {
26738                         MAKE_REAL_ZVAL_PTR(offset);
26739                 }
26740 
26741                 /* here we are sure we are dealing with an object */
26742                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26743 
26744                 PZVAL_LOCK(retval);
26745                 EX_T(opline->result.var).var.ptr = retval;
26746 
26747                 if (1) {
26748                         zval_ptr_dtor(&offset);
26749                 } else {
26750                         zval_dtor(free_op2.var);
26751                 }
26752         }
26753 
26754         CHECK_EXCEPTION();
26755         ZEND_VM_NEXT_OPCODE();
26756 }
26757 
26758 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26759 {
26760         USE_OPLINE
26761 
26762         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
26763                 /* Behave like FETCH_OBJ_W */
26764                 zend_free_op free_op1, free_op2;
26765                 zval *property;
26766                 zval **container;
26767 
26768                 SAVE_OPLINE();
26769                 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26770                 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26771 
26772                 if (1) {
26773                         MAKE_REAL_ZVAL_PTR(property);
26774                 }
26775                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26776                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26777                 }
26778                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
26779                 if (1) {
26780                         zval_ptr_dtor(&property);
26781                 } else {
26782                         zval_dtor(free_op2.var);
26783                 }
26784                 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
26785                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
26786                 }
26787 
26788                 CHECK_EXCEPTION();
26789                 ZEND_VM_NEXT_OPCODE();
26790         } else {
26791                 return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
26792         }
26793 }
26794 
26795 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26796 {
26797         USE_OPLINE
26798         zend_free_op free_op1, free_op2, free_res;
26799         zval **container;
26800         zval *property;
26801 
26802         SAVE_OPLINE();
26803         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26804         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26805 
26806         if (IS_UNUSED == IS_CV) {
26807                 if (container != &EG(uninitialized_zval_ptr)) {
26808                         SEPARATE_ZVAL_IF_NOT_REF(container);
26809                 }
26810         }
26811         if (1) {
26812                 MAKE_REAL_ZVAL_PTR(property);
26813         }
26814         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
26815                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
26816         }
26817         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
26818         if (1) {
26819                 zval_ptr_dtor(&property);
26820         } else {
26821                 zval_dtor(free_op2.var);
26822         }
26823         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
26824                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
26825         }
26826 
26827         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
26828         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
26829                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
26830         }
26831         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
26832         FREE_OP_VAR_PTR(free_res);
26833         CHECK_EXCEPTION();
26834         ZEND_VM_NEXT_OPCODE();
26835 }
26836 
26837 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26838 {
26839         USE_OPLINE
26840         zend_free_op free_op2;
26841         zval **object_ptr;
26842         zval *property_name;
26843 
26844         SAVE_OPLINE();
26845         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
26846         property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26847 
26848         if (1) {
26849                 MAKE_REAL_ZVAL_PTR(property_name);
26850         }
26851         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
26852                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
26853         }
26854         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
26855         if (1) {
26856                 zval_ptr_dtor(&property_name);
26857         } else {
26858                 zval_dtor(free_op2.var);
26859         }
26860 
26861         /* assign_obj has two opcodes! */
26862         CHECK_EXCEPTION();
26863         ZEND_VM_INC_OPCODE();
26864         ZEND_VM_NEXT_OPCODE();
26865 }
26866 
26867 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26868 {
26869         USE_OPLINE
26870         zend_free_op free_op2;
26871         zval *str = &EX_T(opline->result.var).tmp_var;
26872         zval *var;
26873         zval var_copy;
26874         int use_copy = 0;
26875 
26876         SAVE_OPLINE();
26877         var = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26878 
26879         if (IS_UNUSED == IS_UNUSED) {
26880                 /* Initialize for erealloc in add_string_to_string */
26881                 Z_STRVAL_P(str) = NULL;
26882                 Z_STRLEN_P(str) = 0;
26883                 Z_TYPE_P(str) = IS_STRING;
26884 
26885                 INIT_PZVAL(str);
26886         }
26887 
26888         if (Z_TYPE_P(var) != IS_STRING) {
26889                 zend_make_printable_zval(var, &var_copy, &use_copy);
26890 
26891                 if (use_copy) {
26892                         var = &var_copy;
26893                 }
26894         }
26895         add_string_to_string(str, str, var);
26896 
26897         if (use_copy) {
26898                 zval_dtor(var);
26899         }
26900         /* original comment, possibly problematic:
26901          * FREE_OP is missing intentionally here - we're always working on the same temporary variable
26902          * (Zeev):  I don't think it's problematic, we only use variables
26903          * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
26904          * string offsets or overloaded objects
26905          */
26906         zval_dtor(free_op2.var);
26907 
26908         CHECK_EXCEPTION();
26909         ZEND_VM_NEXT_OPCODE();
26910 }
26911 
26912 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26913 {
26914         USE_OPLINE
26915         zval *function_name;
26916         char *function_name_strval;
26917         int function_name_strlen;
26918         zend_free_op free_op2;
26919         call_slot *call = EX(call_slots) + opline->result.num;
26920 
26921         SAVE_OPLINE();
26922 
26923         function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
26924 
26925         if (IS_TMP_VAR != IS_CONST &&
26926             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
26927                 if (UNEXPECTED(EG(exception) != NULL)) {
26928                         HANDLE_EXCEPTION();
26929                 }
26930                 zend_error_noreturn(E_ERROR, "Method name must be a string");
26931         }
26932 
26933         function_name_strval = Z_STRVAL_P(function_name);
26934         function_name_strlen = Z_STRLEN_P(function_name);
26935 
26936         call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
26937 
26938         if (EXPECTED(call->object != NULL) &&
26939             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
26940                 call->called_scope = Z_OBJCE_P(call->object);
26941 
26942                 if (IS_TMP_VAR != IS_CONST ||
26943                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
26944                     zval *object = call->object;
26945 
26946                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
26947                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
26948                         }
26949 
26950                         /* First, locate the function. */
26951                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
26952                         if (UNEXPECTED(call->fbc == NULL)) {
26953                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
26954                         }
26955                         if (IS_TMP_VAR == IS_CONST &&
26956                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
26957                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
26958                             EXPECTED(call->object == object)) {
26959                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
26960                         }
26961                 }
26962         } else {
26963                 if (UNEXPECTED(EG(exception) != NULL)) {
26964                         zval_dtor(free_op2.var);
26965                         HANDLE_EXCEPTION();
26966                 }
26967                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
26968         }
26969 
26970         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
26971                 call->object = NULL;
26972         } else {
26973                 if (!PZVAL_IS_REF(call->object)) {
26974                         Z_ADDREF_P(call->object); /* For $this pointer */
26975                 } else {
26976                         zval *this_ptr;
26977                         ALLOC_ZVAL(this_ptr);
26978                         INIT_PZVAL_COPY(this_ptr, call->object);
26979                         zval_copy_ctor(this_ptr);
26980                         call->object = this_ptr;
26981                 }
26982         }
26983 
26984         call->num_additional_args = 0;
26985         call->is_ctor_call = 0;
26986         EX(call) = call;
26987 
26988         zval_dtor(free_op2.var);
26989 
26990         CHECK_EXCEPTION();
26991         ZEND_VM_NEXT_OPCODE();
26992 }
26993 
26994 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26995 {
26996         USE_OPLINE
26997 
26998         array_init(&EX_T(opline->result.var).tmp_var);
26999         if (IS_UNUSED == IS_UNUSED) {
27000                 ZEND_VM_NEXT_OPCODE();
27001 #if 0 || IS_UNUSED != IS_UNUSED
27002         } else {
27003                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27004 #endif
27005         }
27006 }
27007 
27008 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27009 {
27010         USE_OPLINE
27011         zend_free_op free_op2;
27012         zval **container;
27013         zval *offset;
27014         ulong hval;
27015 
27016         SAVE_OPLINE();
27017         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27018         if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
27019                 SEPARATE_ZVAL_IF_NOT_REF(container);
27020         }
27021         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27022 
27023         if (IS_UNUSED != IS_VAR || container) {
27024                 switch (Z_TYPE_PP(container)) {
27025                         case IS_ARRAY: {
27026                                 HashTable *ht = Z_ARRVAL_PP(container);
27027 
27028                                 switch (Z_TYPE_P(offset)) {
27029                                         case IS_DOUBLE:
27030                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
27031                                                 zend_hash_index_del(ht, hval);
27032                                                 break;
27033                                         case IS_RESOURCE:
27034                                         case IS_BOOL:
27035                                         case IS_LONG:
27036                                                 hval = Z_LVAL_P(offset);
27037                                                 zend_hash_index_del(ht, hval);
27038                                                 break;
27039                                         case IS_STRING:
27040                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27041                                                         Z_ADDREF_P(offset);
27042                                                 }
27043                                                 if (IS_TMP_VAR == IS_CONST) {
27044                                                         hval = Z_HASH_P(offset);
27045                                                 } else {
27046                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
27047                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
27048                                                 }
27049                                                 if (ht == &EG(symbol_table)) {
27050                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
27051                                                 } else {
27052                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
27053                                                 }
27054                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27055                                                         zval_ptr_dtor(&offset);
27056                                                 }
27057                                                 break;
27058 num_index_dim:
27059                                                 zend_hash_index_del(ht, hval);
27060                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27061                                                         zval_ptr_dtor(&offset);
27062                                                 }
27063                                                 break;
27064                                         case IS_NULL:
27065                                                 zend_hash_del(ht, "", sizeof(""));
27066                                                 break;
27067                                         default:
27068                                                 zend_error(E_WARNING, "Illegal offset type in unset");
27069                                                 break;
27070                                 }
27071                                 zval_dtor(free_op2.var);
27072                                 break;
27073                         }
27074                         case IS_OBJECT:
27075                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
27076                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
27077                                 }
27078                                 if (1) {
27079                                         MAKE_REAL_ZVAL_PTR(offset);
27080                                 }
27081                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
27082                                 if (1) {
27083                                         zval_ptr_dtor(&offset);
27084                                 } else {
27085                                         zval_dtor(free_op2.var);
27086                                 }
27087                                 break;
27088                         case IS_STRING:
27089                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
27090                                 ZEND_VM_CONTINUE(); /* bailed out before */
27091                         default:
27092                                 zval_dtor(free_op2.var);
27093                                 break;
27094                 }
27095         } else {
27096                 zval_dtor(free_op2.var);
27097         }
27098 
27099         CHECK_EXCEPTION();
27100         ZEND_VM_NEXT_OPCODE();
27101 }
27102 
27103 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27104 {
27105         USE_OPLINE
27106         zend_free_op free_op2;
27107         zval **container;
27108         zval *offset;
27109 
27110         SAVE_OPLINE();
27111         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27112         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27113 
27114         if (IS_UNUSED != IS_VAR || container) {
27115                 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
27116                         SEPARATE_ZVAL_IF_NOT_REF(container);
27117                 }
27118                 if (Z_TYPE_PP(container) == IS_OBJECT) {
27119                         if (1) {
27120                                 MAKE_REAL_ZVAL_PTR(offset);
27121                         }
27122                         if (Z_OBJ_HT_P(*container)->unset_property) {
27123                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27124                         } else {
27125                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
27126                         }
27127                         if (1) {
27128                                 zval_ptr_dtor(&offset);
27129                         } else {
27130                                 zval_dtor(free_op2.var);
27131                         }
27132                 } else {
27133                         zval_dtor(free_op2.var);
27134                 }
27135         } else {
27136                 zval_dtor(free_op2.var);
27137         }
27138 
27139         CHECK_EXCEPTION();
27140         ZEND_VM_NEXT_OPCODE();
27141 }
27142 
27143 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
27144 {
27145         USE_OPLINE
27146         zend_free_op free_op2;
27147         zval *container;
27148         zval **value = NULL;
27149         int result = 0;
27150         ulong hval;
27151         zval *offset;
27152 
27153         SAVE_OPLINE();
27154         container = _get_obj_zval_ptr_unused(TSRMLS_C);
27155         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27156 
27157         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
27158                 HashTable *ht;
27159                 int isset = 0;
27160 
27161                 ht = Z_ARRVAL_P(container);
27162 
27163                 switch (Z_TYPE_P(offset)) {
27164                         case IS_DOUBLE:
27165                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
27166                                 goto num_index_prop;
27167                         case IS_RESOURCE:
27168                         case IS_BOOL:
27169                         case IS_LONG:
27170                                 hval = Z_LVAL_P(offset);
27171 num_index_prop:
27172                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
27173                                         isset = 1;
27174                                 }
27175                                 break;
27176                         case IS_STRING:
27177                                 if (IS_TMP_VAR == IS_CONST) {
27178                                         hval = Z_HASH_P(offset);
27179                                 } else {
27180                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
27181                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
27182                                 }
27183                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
27184                                         isset = 1;
27185                                 }
27186                                 break;
27187                         case IS_NULL:
27188                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
27189                                         isset = 1;
27190                                 }
27191                                 break;
27192                         default:
27193                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
27194                                 break;
27195                 }
27196 
27197                 if (opline->extended_value & ZEND_ISSET) {
27198                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
27199                                 result = 0;
27200                         } else {
27201                                 result = isset;
27202                         }
27203                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
27204                         if (!isset || !i_zend_is_true(*value)) {
27205                                 result = 0;
27206                         } else {
27207                                 result = 1;
27208                         }
27209                 }
27210                 zval_dtor(free_op2.var);
27211         } else if (Z_TYPE_P(container) == IS_OBJECT) {
27212                 if (1) {
27213                         MAKE_REAL_ZVAL_PTR(offset);
27214                 }
27215                 if (prop_dim) {
27216                         if (Z_OBJ_HT_P(container)->has_property) {
27217                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27218                         } else {
27219                                 zend_error(E_NOTICE, "Trying to check property of non-object");
27220                                 result = 0;
27221                         }
27222                 } else {
27223                         if (Z_OBJ_HT_P(container)->has_dimension) {
27224                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
27225                         } else {
27226                                 zend_error(E_NOTICE, "Trying to check element of non-array");
27227                                 result = 0;
27228                         }
27229                 }
27230                 if (1) {
27231                         zval_ptr_dtor(&offset);
27232                 } else {
27233                         zval_dtor(free_op2.var);
27234                 }
27235         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
27236                 zval tmp;
27237 
27238                 if (Z_TYPE_P(offset) != IS_LONG) {
27239                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
27240                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
27241                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
27242                                 ZVAL_COPY_VALUE(&tmp, offset);
27243                                 zval_copy_ctor(&tmp);
27244                                 convert_to_long(&tmp);
27245                                 offset = &tmp;
27246                         } else {
27247                                 /* can not be converted to proper offset, return "not set" */
27248                                 result = 0;
27249                         }
27250                 }
27251                 if (Z_TYPE_P(offset) == IS_LONG) {
27252                         if (opline->extended_value & ZEND_ISSET) {
27253                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
27254                                         result = 1;
27255                                 }
27256                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
27257                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
27258                                         result = 1;
27259                                 }
27260                         }
27261                 }
27262                 zval_dtor(free_op2.var);
27263         } else {
27264                 zval_dtor(free_op2.var);
27265         }
27266 
27267         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
27268         if (opline->extended_value & ZEND_ISSET) {
27269                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
27270         } else {
27271                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
27272         }
27273 
27274         CHECK_EXCEPTION();
27275         ZEND_VM_NEXT_OPCODE();
27276 }
27277 
27278 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27279 {
27280         return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27281 }
27282 
27283 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27284 {
27285         return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27286 }
27287 
27288 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27289 {
27290         USE_OPLINE
27291 
27292         /* The generator object is stored in return_value_ptr_ptr */
27293         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
27294 
27295         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
27296                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
27297         }
27298 
27299         /* Destroy the previously yielded value */
27300         if (generator->value) {
27301                 zval_ptr_dtor(&generator->value);
27302         }
27303 
27304         /* Destroy the previously yielded key */
27305         if (generator->key) {
27306                 zval_ptr_dtor(&generator->key);
27307         }
27308 
27309         /* Set the new yielded value */
27310         if (IS_UNUSED != IS_UNUSED) {
27311 
27312 
27313                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
27314                         /* Constants and temporary variables aren't yieldable by reference,
27315                          * but we still allow them with a notice. */
27316                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
27317                                 zval *value, *copy;
27318 
27319                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
27320 
27321                                 value = NULL;
27322                                 ALLOC_ZVAL(copy);
27323                                 INIT_PZVAL_COPY(copy, value);
27324 
27325                                 /* Temporary variables don't need ctor copying */
27326                                 if (!0) {
27327                                         zval_copy_ctor(copy);
27328                                 }
27329 
27330                                 generator->value = copy;
27331                         } else {
27332                                 zval **value_ptr = NULL;
27333 
27334                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
27335                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
27336                                 }
27337 
27338                                 /* If a function call result is yielded and the function did
27339                                  * not return by reference we throw a notice. */
27340                                 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
27341                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
27342                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
27343                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
27344                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
27345 
27346                                         Z_ADDREF_PP(value_ptr);
27347                                         generator->value = *value_ptr;
27348                                 } else {
27349                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
27350                                         Z_ADDREF_PP(value_ptr);
27351                                         generator->value = *value_ptr;
27352                                 }
27353 
27354                         }
27355                 } else {
27356                         zval *value = NULL;
27357 
27358                         /* Consts, temporary variables and references need copying */
27359                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
27360                                 || PZVAL_IS_REF(value)
27361                         ) {
27362                                 zval *copy;
27363 
27364                                 ALLOC_ZVAL(copy);
27365                                 INIT_PZVAL_COPY(copy, value);
27366 
27367                                 /* Temporary variables don't need ctor copying */
27368                                 if (!0) {
27369                                         zval_copy_ctor(copy);
27370                                 }
27371 
27372                                 generator->value = copy;
27373 
27374                         } else {
27375                                 if (IS_UNUSED == IS_CV) {
27376                                         Z_ADDREF_P(value);
27377                                 }
27378                                 generator->value = value;
27379                         }
27380                 }
27381         } else {
27382                 /* If no value was specified yield null */
27383                 Z_ADDREF(EG(uninitialized_zval));
27384                 generator->value = &EG(uninitialized_zval);
27385         }
27386 
27387         /* Set the new yielded key */
27388         if (IS_TMP_VAR != IS_UNUSED) {
27389                 zend_free_op free_op2;
27390                 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27391 
27392                 /* Consts, temporary variables and references need copying */
27393                 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
27394                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
27395                 ) {
27396                         zval *copy;
27397 
27398                         ALLOC_ZVAL(copy);
27399                         INIT_PZVAL_COPY(copy, key);
27400 
27401                         /* Temporary variables don't need ctor copying */
27402                         if (!1) {
27403                                 zval_copy_ctor(copy);
27404                         }
27405 
27406                         generator->key = copy;
27407                 } else {
27408                         Z_ADDREF_P(key);
27409                         generator->key = key;
27410                 }
27411 
27412                 if (Z_TYPE_P(generator->key) == IS_LONG
27413                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
27414                 ) {
27415                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
27416                 }
27417 
27418         } else {
27419                 /* If no key was specified we use auto-increment keys */
27420                 generator->largest_used_integer_key++;
27421 
27422                 ALLOC_INIT_ZVAL(generator->key);
27423                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
27424         }
27425 
27426         if (RETURN_VALUE_USED(opline)) {
27427                 /* If the return value of yield is used set the send
27428                  * target and initialize it to NULL */
27429                 generator->send_target = &EX_T(opline->result.var).var.ptr;
27430                 Z_ADDREF(EG(uninitialized_zval));
27431                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27432         } else {
27433                 generator->send_target = NULL;
27434         }
27435 
27436         /* We increment to the next op, so we are at the correct position when the
27437          * generator is resumed. */
27438         ZEND_VM_INC_OPCODE();
27439 
27440         /* The GOTO VM uses a local opline variable. We need to set the opline
27441          * variable in execute_data so we don't resume at an old position. */
27442         SAVE_OPLINE();
27443 
27444         ZEND_VM_RETURN();
27445 }
27446 
27447 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27448 {
27449         return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27450 }
27451 
27452 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
27453 {
27454         USE_OPLINE
27455         zend_free_op free_op2, free_op_data1;
27456         zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27457         zval *object;
27458         zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27459         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
27460         int have_get_ptr = 0;
27461 
27462         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
27463                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
27464         }
27465 
27466         make_real_object(object_ptr TSRMLS_CC);
27467         object = *object_ptr;
27468 
27469         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27470                 zend_error(E_WARNING, "Attempt to assign property of non-object");
27471                 zval_ptr_dtor_nogc(&free_op2.var);
27472                 FREE_OP(free_op_data1);
27473 
27474                 if (RETURN_VALUE_USED(opline)) {
27475                         PZVAL_LOCK(&EG(uninitialized_zval));
27476                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27477                 }
27478         } else {
27479                 /* here we are sure we are dealing with an object */
27480                 if (0) {
27481                         MAKE_REAL_ZVAL_PTR(property);
27482                 }
27483 
27484                 /* here property is a string */
27485                 if (opline->extended_value == ZEND_ASSIGN_OBJ
27486                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
27487                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27488                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
27489                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
27490 
27491                                 have_get_ptr = 1;
27492                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
27493                                 if (RETURN_VALUE_USED(opline)) {
27494                                         PZVAL_LOCK(*zptr);
27495                                         EX_T(opline->result.var).var.ptr = *zptr;
27496                                 }
27497                         }
27498                 }
27499 
27500                 if (!have_get_ptr) {
27501                         zval *z = NULL;
27502 
27503                         Z_ADDREF_P(object);
27504                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
27505                                 if (Z_OBJ_HT_P(object)->read_property) {
27506                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27507                                 }
27508                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
27509                                 if (Z_OBJ_HT_P(object)->read_dimension) {
27510                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
27511                                 }
27512                         }
27513                         if (z) {
27514                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
27515                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
27516 
27517                                         if (Z_REFCOUNT_P(z) == 0) {
27518                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
27519                                                 zval_dtor(z);
27520                                                 FREE_ZVAL(z);
27521                                         }
27522                                         z = value;
27523                                 }
27524                                 Z_ADDREF_P(z);
27525                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
27526                                 binary_op(z, z, value TSRMLS_CC);
27527                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
27528                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27529                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
27530                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
27531                                 }
27532                                 if (RETURN_VALUE_USED(opline)) {
27533                                         PZVAL_LOCK(z);
27534                                         EX_T(opline->result.var).var.ptr = z;
27535                                 }
27536                                 zval_ptr_dtor(&z);
27537                         } else {
27538                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
27539                                 if (RETURN_VALUE_USED(opline)) {
27540                                         PZVAL_LOCK(&EG(uninitialized_zval));
27541                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27542                                 }
27543                         }
27544                         zval_ptr_dtor(&object);
27545                 }
27546 
27547                 if (0) {
27548                         zval_ptr_dtor(&property);
27549                 } else {
27550                         zval_ptr_dtor_nogc(&free_op2.var);
27551                 }
27552                 FREE_OP(free_op_data1);
27553         }
27554 
27555         /* assign_obj has two opcodes! */
27556         CHECK_EXCEPTION();
27557         ZEND_VM_INC_OPCODE();
27558         ZEND_VM_NEXT_OPCODE();
27559 }
27560 
27561 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
27562 {
27563         USE_OPLINE
27564         zend_free_op free_op2, free_op_data2, free_op_data1;
27565         zval **var_ptr;
27566         zval *value;
27567 
27568         SAVE_OPLINE();
27569         switch (opline->extended_value) {
27570                 case ZEND_ASSIGN_OBJ:
27571                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27572                         break;
27573                 case ZEND_ASSIGN_DIM: {
27574                                 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27575 
27576                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
27577                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
27578                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
27579                                         if (IS_UNUSED == IS_VAR && !0) {
27580                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
27581                                         }
27582                                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27583                                 } else {
27584                                         zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27585 
27586                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
27587                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
27588                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
27589                                 }
27590                         }
27591                         break;
27592                 default:
27593                         value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27594                         var_ptr = NULL;
27595                         /* do nothing */
27596                         break;
27597         }
27598 
27599         if (UNEXPECTED(var_ptr == NULL)) {
27600                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
27601         }
27602 
27603         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
27604                 if (RETURN_VALUE_USED(opline)) {
27605                         PZVAL_LOCK(&EG(uninitialized_zval));
27606                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27607                 }
27608                 zval_ptr_dtor_nogc(&free_op2.var);
27609 
27610                 CHECK_EXCEPTION();
27611                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
27612                         ZEND_VM_INC_OPCODE();
27613                 }
27614                 ZEND_VM_NEXT_OPCODE();
27615         }
27616 
27617         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
27618 
27619         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
27620            && Z_OBJ_HANDLER_PP(var_ptr, get)
27621            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
27622                 /* proxy object */
27623                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
27624                 Z_ADDREF_P(objval);
27625                 binary_op(objval, objval, value TSRMLS_CC);
27626                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
27627                 zval_ptr_dtor(&objval);
27628         } else {
27629                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
27630         }
27631 
27632         if (RETURN_VALUE_USED(opline)) {
27633                 PZVAL_LOCK(*var_ptr);
27634                 EX_T(opline->result.var).var.ptr = *var_ptr;
27635         }
27636         zval_ptr_dtor_nogc(&free_op2.var);
27637 
27638         if (opline->extended_value == ZEND_ASSIGN_DIM) {
27639                 FREE_OP(free_op_data1);
27640                 FREE_OP_VAR_PTR(free_op_data2);
27641 
27642                 CHECK_EXCEPTION();
27643                 ZEND_VM_INC_OPCODE();
27644         } else {
27645 
27646                 CHECK_EXCEPTION();
27647         }
27648         ZEND_VM_NEXT_OPCODE();
27649 }
27650 
27651 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27652 {
27653         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27654 }
27655 
27656 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27657 {
27658         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27659 }
27660 
27661 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27662 {
27663         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27664 }
27665 
27666 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27667 {
27668         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27669 }
27670 
27671 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27672 {
27673         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27674 }
27675 
27676 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27677 {
27678         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27679 }
27680 
27681 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27682 {
27683         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27684 }
27685 
27686 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27687 {
27688         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27689 }
27690 
27691 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27692 {
27693         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27694 }
27695 
27696 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27697 {
27698         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27699 }
27700 
27701 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27702 {
27703         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27704 }
27705 
27706 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
27707 {
27708         USE_OPLINE
27709         zend_free_op free_op2;
27710         zval **object_ptr;
27711         zval *object;
27712         zval *property;
27713         zval **retval;
27714         int have_get_ptr = 0;
27715 
27716         SAVE_OPLINE();
27717         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27718         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27719         retval = &EX_T(opline->result.var).var.ptr;
27720 
27721         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
27722                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
27723         }
27724 
27725         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
27726         object = *object_ptr;
27727 
27728         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27729                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
27730                 zval_ptr_dtor_nogc(&free_op2.var);
27731                 if (RETURN_VALUE_USED(opline)) {
27732                         PZVAL_LOCK(&EG(uninitialized_zval));
27733                         *retval = &EG(uninitialized_zval);
27734                 }
27735 
27736                 CHECK_EXCEPTION();
27737                 ZEND_VM_NEXT_OPCODE();
27738         }
27739 
27740         /* here we are sure we are dealing with an object */
27741 
27742         if (0) {
27743                 MAKE_REAL_ZVAL_PTR(property);
27744         }
27745 
27746         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
27747                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27748                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
27749                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
27750 
27751                         have_get_ptr = 1;
27752                         incdec_op(*zptr);
27753                         if (RETURN_VALUE_USED(opline)) {
27754                                 *retval = *zptr;
27755                                 PZVAL_LOCK(*retval);
27756                         }
27757                 }
27758         }
27759 
27760         if (!have_get_ptr) {
27761                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
27762                         zval *z;
27763 
27764                         Z_ADDREF_P(object);
27765                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27766 
27767                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
27768                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
27769 
27770                                 if (Z_REFCOUNT_P(z) == 0) {
27771                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
27772                                         zval_dtor(z);
27773                                         FREE_ZVAL(z);
27774                                 }
27775                                 z = value;
27776                         }
27777                         Z_ADDREF_P(z);
27778                         SEPARATE_ZVAL_IF_NOT_REF(&z);
27779                         incdec_op(z);
27780                         *retval = z;
27781                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27782                         zval_ptr_dtor(&object);
27783                         SELECTIVE_PZVAL_LOCK(*retval, opline);
27784                         zval_ptr_dtor(&z);
27785                 } else {
27786                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
27787                         if (RETURN_VALUE_USED(opline)) {
27788                                 PZVAL_LOCK(&EG(uninitialized_zval));
27789                                 *retval = &EG(uninitialized_zval);
27790                         }
27791                 }
27792         }
27793 
27794         if (0) {
27795                 zval_ptr_dtor(&property);
27796         } else {
27797                 zval_ptr_dtor_nogc(&free_op2.var);
27798         }
27799 
27800         CHECK_EXCEPTION();
27801         ZEND_VM_NEXT_OPCODE();
27802 }
27803 
27804 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27805 {
27806         return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27807 }
27808 
27809 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27810 {
27811         return zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27812 }
27813 
27814 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
27815 {
27816         USE_OPLINE
27817         zend_free_op free_op2;
27818         zval **object_ptr;
27819         zval *object;
27820         zval *property;
27821         zval *retval;
27822         int have_get_ptr = 0;
27823 
27824         SAVE_OPLINE();
27825         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27826         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27827         retval = &EX_T(opline->result.var).tmp_var;
27828 
27829         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
27830                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
27831         }
27832 
27833         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
27834         object = *object_ptr;
27835 
27836         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27837                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
27838                 zval_ptr_dtor_nogc(&free_op2.var);
27839                 ZVAL_NULL(retval);
27840 
27841                 CHECK_EXCEPTION();
27842                 ZEND_VM_NEXT_OPCODE();
27843         }
27844 
27845         /* here we are sure we are dealing with an object */
27846 
27847         if (0) {
27848                 MAKE_REAL_ZVAL_PTR(property);
27849         }
27850 
27851         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
27852                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27853                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
27854                         have_get_ptr = 1;
27855                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
27856 
27857                         ZVAL_COPY_VALUE(retval, *zptr);
27858                         zendi_zval_copy_ctor(*retval);
27859 
27860                         incdec_op(*zptr);
27861 
27862                 }
27863         }
27864 
27865         if (!have_get_ptr) {
27866                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
27867                         zval *z, *z_copy;
27868 
27869                         Z_ADDREF_P(object);
27870                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27871                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
27872                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
27873 
27874                                 if (Z_REFCOUNT_P(z) == 0) {
27875                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
27876                                         zval_dtor(z);
27877                                         FREE_ZVAL(z);
27878                                 }
27879                                 z = value;
27880                         }
27881                         ZVAL_COPY_VALUE(retval, z);
27882                         zendi_zval_copy_ctor(*retval);
27883                         ALLOC_ZVAL(z_copy);
27884                         INIT_PZVAL_COPY(z_copy, z);
27885                         zendi_zval_copy_ctor(*z_copy);
27886                         incdec_op(z_copy);
27887                         Z_ADDREF_P(z);
27888                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27889                         zval_ptr_dtor(&object);
27890                         zval_ptr_dtor(&z_copy);
27891                         zval_ptr_dtor(&z);
27892                 } else {
27893                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
27894                         ZVAL_NULL(retval);
27895                 }
27896         }
27897 
27898         if (0) {
27899                 zval_ptr_dtor(&property);
27900         } else {
27901                 zval_ptr_dtor_nogc(&free_op2.var);
27902         }
27903 
27904         CHECK_EXCEPTION();
27905         ZEND_VM_NEXT_OPCODE();
27906 }
27907 
27908 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27909 {
27910         return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27911 }
27912 
27913 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27914 {
27915         return zend_post_incdec_property_helper_SPEC_UNUSED_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27916 }
27917 
27918 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS)
27919 {
27920         USE_OPLINE
27921 
27922         zval *container;
27923         zend_free_op free_op2;
27924         zval *offset;
27925 
27926         SAVE_OPLINE();
27927         container = _get_obj_zval_ptr_unused(TSRMLS_C);
27928         offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27929 
27930         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
27931             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
27932                 zend_error(E_NOTICE, "Trying to get property of non-object");
27933                 PZVAL_LOCK(&EG(uninitialized_zval));
27934                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
27935                 zval_ptr_dtor_nogc(&free_op2.var);
27936         } else {
27937                 zval *retval;
27938 
27939                 if (0) {
27940                         MAKE_REAL_ZVAL_PTR(offset);
27941                 }
27942 
27943                 /* here we are sure we are dealing with an object */
27944                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
27945 
27946                 PZVAL_LOCK(retval);
27947                 EX_T(opline->result.var).var.ptr = retval;
27948 
27949                 if (0) {
27950                         zval_ptr_dtor(&offset);
27951                 } else {
27952                         zval_ptr_dtor_nogc(&free_op2.var);
27953                 }
27954         }
27955 
27956         CHECK_EXCEPTION();
27957         ZEND_VM_NEXT_OPCODE();
27958 }
27959 
27960 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27961 {
27962         return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
27963 }
27964 
27965 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27966 {
27967         USE_OPLINE
27968         zend_free_op free_op1, free_op2;
27969         zval *property;
27970         zval **container;
27971 
27972         SAVE_OPLINE();
27973         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
27974 
27975         if (0) {
27976                 MAKE_REAL_ZVAL_PTR(property);
27977         }
27978         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
27979         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
27980                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
27981         }
27982 
27983         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
27984         if (0) {
27985                 zval_ptr_dtor(&property);
27986         } else {
27987                 zval_ptr_dtor_nogc(&free_op2.var);
27988         }
27989         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
27990                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
27991         }
27992 
27993         /* We are going to assign the result by reference */
27994         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
27995                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
27996 
27997                 Z_DELREF_PP(retval_ptr);
27998                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
27999                 Z_ADDREF_PP(retval_ptr);
28000                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
28001                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
28002         }
28003 
28004         CHECK_EXCEPTION();
28005         ZEND_VM_NEXT_OPCODE();
28006 }
28007 
28008 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28009 {
28010         USE_OPLINE
28011         zend_free_op free_op1, free_op2;
28012         zval *property;
28013         zval **container;
28014 
28015         SAVE_OPLINE();
28016         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28017         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28018 
28019         if (0) {
28020                 MAKE_REAL_ZVAL_PTR(property);
28021         }
28022         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
28023                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28024         }
28025         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
28026         if (0) {
28027                 zval_ptr_dtor(&property);
28028         } else {
28029                 zval_ptr_dtor_nogc(&free_op2.var);
28030         }
28031         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
28032                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
28033         }
28034 
28035         CHECK_EXCEPTION();
28036         ZEND_VM_NEXT_OPCODE();
28037 }
28038 
28039 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28040 {
28041         USE_OPLINE
28042 
28043         zval *container;
28044         zend_free_op free_op2;
28045         zval *offset;
28046 
28047         SAVE_OPLINE();
28048         container = _get_obj_zval_ptr_unused(TSRMLS_C);
28049         offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28050 
28051         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
28052             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
28053                 PZVAL_LOCK(&EG(uninitialized_zval));
28054                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28055                 zval_ptr_dtor_nogc(&free_op2.var);
28056         } else {
28057                 zval *retval;
28058 
28059                 if (0) {
28060                         MAKE_REAL_ZVAL_PTR(offset);
28061                 }
28062 
28063                 /* here we are sure we are dealing with an object */
28064                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28065 
28066                 PZVAL_LOCK(retval);
28067                 EX_T(opline->result.var).var.ptr = retval;
28068 
28069                 if (0) {
28070                         zval_ptr_dtor(&offset);
28071                 } else {
28072                         zval_ptr_dtor_nogc(&free_op2.var);
28073                 }
28074         }
28075 
28076         CHECK_EXCEPTION();
28077         ZEND_VM_NEXT_OPCODE();
28078 }
28079 
28080 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28081 {
28082         USE_OPLINE
28083 
28084         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
28085                 /* Behave like FETCH_OBJ_W */
28086                 zend_free_op free_op1, free_op2;
28087                 zval *property;
28088                 zval **container;
28089 
28090                 SAVE_OPLINE();
28091                 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28092                 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28093 
28094                 if (0) {
28095                         MAKE_REAL_ZVAL_PTR(property);
28096                 }
28097                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
28098                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28099                 }
28100                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
28101                 if (0) {
28102                         zval_ptr_dtor(&property);
28103                 } else {
28104                         zval_ptr_dtor_nogc(&free_op2.var);
28105                 }
28106                 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
28107                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
28108                 }
28109 
28110                 CHECK_EXCEPTION();
28111                 ZEND_VM_NEXT_OPCODE();
28112         } else {
28113                 return zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28114         }
28115 }
28116 
28117 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28118 {
28119         USE_OPLINE
28120         zend_free_op free_op1, free_op2, free_res;
28121         zval **container;
28122         zval *property;
28123 
28124         SAVE_OPLINE();
28125         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28126         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28127 
28128         if (IS_UNUSED == IS_CV) {
28129                 if (container != &EG(uninitialized_zval_ptr)) {
28130                         SEPARATE_ZVAL_IF_NOT_REF(container);
28131                 }
28132         }
28133         if (0) {
28134                 MAKE_REAL_ZVAL_PTR(property);
28135         }
28136         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
28137                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28138         }
28139         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
28140         if (0) {
28141                 zval_ptr_dtor(&property);
28142         } else {
28143                 zval_ptr_dtor_nogc(&free_op2.var);
28144         }
28145         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
28146                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
28147         }
28148 
28149         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
28150         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
28151                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
28152         }
28153         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
28154         FREE_OP_VAR_PTR(free_res);
28155         CHECK_EXCEPTION();
28156         ZEND_VM_NEXT_OPCODE();
28157 }
28158 
28159 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28160 {
28161         USE_OPLINE
28162         zend_free_op free_op2;
28163         zval **object_ptr;
28164         zval *property_name;
28165 
28166         SAVE_OPLINE();
28167         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28168         property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28169 
28170         if (0) {
28171                 MAKE_REAL_ZVAL_PTR(property_name);
28172         }
28173         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
28174                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28175         }
28176         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28177         if (0) {
28178                 zval_ptr_dtor(&property_name);
28179         } else {
28180                 zval_ptr_dtor_nogc(&free_op2.var);
28181         }
28182 
28183         /* assign_obj has two opcodes! */
28184         CHECK_EXCEPTION();
28185         ZEND_VM_INC_OPCODE();
28186         ZEND_VM_NEXT_OPCODE();
28187 }
28188 
28189 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28190 {
28191         USE_OPLINE
28192         zend_free_op free_op2;
28193         zval *str = &EX_T(opline->result.var).tmp_var;
28194         zval *var;
28195         zval var_copy;
28196         int use_copy = 0;
28197 
28198         SAVE_OPLINE();
28199         var = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28200 
28201         if (IS_UNUSED == IS_UNUSED) {
28202                 /* Initialize for erealloc in add_string_to_string */
28203                 Z_STRVAL_P(str) = NULL;
28204                 Z_STRLEN_P(str) = 0;
28205                 Z_TYPE_P(str) = IS_STRING;
28206 
28207                 INIT_PZVAL(str);
28208         }
28209 
28210         if (Z_TYPE_P(var) != IS_STRING) {
28211                 zend_make_printable_zval(var, &var_copy, &use_copy);
28212 
28213                 if (use_copy) {
28214                         var = &var_copy;
28215                 }
28216         }
28217         add_string_to_string(str, str, var);
28218 
28219         if (use_copy) {
28220                 zval_dtor(var);
28221         }
28222         /* original comment, possibly problematic:
28223          * FREE_OP is missing intentionally here - we're always working on the same temporary variable
28224          * (Zeev):  I don't think it's problematic, we only use variables
28225          * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
28226          * string offsets or overloaded objects
28227          */
28228         zval_ptr_dtor_nogc(&free_op2.var);
28229 
28230         CHECK_EXCEPTION();
28231         ZEND_VM_NEXT_OPCODE();
28232 }
28233 
28234 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28235 {
28236         USE_OPLINE
28237         zval *function_name;
28238         char *function_name_strval;
28239         int function_name_strlen;
28240         zend_free_op free_op2;
28241         call_slot *call = EX(call_slots) + opline->result.num;
28242 
28243         SAVE_OPLINE();
28244 
28245         function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28246 
28247         if (IS_VAR != IS_CONST &&
28248             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
28249                 if (UNEXPECTED(EG(exception) != NULL)) {
28250                         HANDLE_EXCEPTION();
28251                 }
28252                 zend_error_noreturn(E_ERROR, "Method name must be a string");
28253         }
28254 
28255         function_name_strval = Z_STRVAL_P(function_name);
28256         function_name_strlen = Z_STRLEN_P(function_name);
28257 
28258         call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
28259 
28260         if (EXPECTED(call->object != NULL) &&
28261             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
28262                 call->called_scope = Z_OBJCE_P(call->object);
28263 
28264                 if (IS_VAR != IS_CONST ||
28265                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
28266                     zval *object = call->object;
28267 
28268                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
28269                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
28270                         }
28271 
28272                         /* First, locate the function. */
28273                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
28274                         if (UNEXPECTED(call->fbc == NULL)) {
28275                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
28276                         }
28277                         if (IS_VAR == IS_CONST &&
28278                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
28279                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
28280                             EXPECTED(call->object == object)) {
28281                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
28282                         }
28283                 }
28284         } else {
28285                 if (UNEXPECTED(EG(exception) != NULL)) {
28286                         zval_ptr_dtor_nogc(&free_op2.var);
28287                         HANDLE_EXCEPTION();
28288                 }
28289                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
28290         }
28291 
28292         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
28293                 call->object = NULL;
28294         } else {
28295                 if (!PZVAL_IS_REF(call->object)) {
28296                         Z_ADDREF_P(call->object); /* For $this pointer */
28297                 } else {
28298                         zval *this_ptr;
28299                         ALLOC_ZVAL(this_ptr);
28300                         INIT_PZVAL_COPY(this_ptr, call->object);
28301                         zval_copy_ctor(this_ptr);
28302                         call->object = this_ptr;
28303                 }
28304         }
28305 
28306         call->num_additional_args = 0;
28307         call->is_ctor_call = 0;
28308         EX(call) = call;
28309 
28310         zval_ptr_dtor_nogc(&free_op2.var);
28311 
28312         CHECK_EXCEPTION();
28313         ZEND_VM_NEXT_OPCODE();
28314 }
28315 
28316 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28317 {
28318         USE_OPLINE
28319 
28320         array_init(&EX_T(opline->result.var).tmp_var);
28321         if (IS_UNUSED == IS_UNUSED) {
28322                 ZEND_VM_NEXT_OPCODE();
28323 #if 0 || IS_UNUSED != IS_UNUSED
28324         } else {
28325                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28326 #endif
28327         }
28328 }
28329 
28330 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28331 {
28332         USE_OPLINE
28333         zend_free_op free_op2;
28334         zval **container;
28335         zval *offset;
28336         ulong hval;
28337 
28338         SAVE_OPLINE();
28339         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28340         if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
28341                 SEPARATE_ZVAL_IF_NOT_REF(container);
28342         }
28343         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28344 
28345         if (IS_UNUSED != IS_VAR || container) {
28346                 switch (Z_TYPE_PP(container)) {
28347                         case IS_ARRAY: {
28348                                 HashTable *ht = Z_ARRVAL_PP(container);
28349 
28350                                 switch (Z_TYPE_P(offset)) {
28351                                         case IS_DOUBLE:
28352                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
28353                                                 zend_hash_index_del(ht, hval);
28354                                                 break;
28355                                         case IS_RESOURCE:
28356                                         case IS_BOOL:
28357                                         case IS_LONG:
28358                                                 hval = Z_LVAL_P(offset);
28359                                                 zend_hash_index_del(ht, hval);
28360                                                 break;
28361                                         case IS_STRING:
28362                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28363                                                         Z_ADDREF_P(offset);
28364                                                 }
28365                                                 if (IS_VAR == IS_CONST) {
28366                                                         hval = Z_HASH_P(offset);
28367                                                 } else {
28368                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
28369                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
28370                                                 }
28371                                                 if (ht == &EG(symbol_table)) {
28372                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
28373                                                 } else {
28374                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
28375                                                 }
28376                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28377                                                         zval_ptr_dtor(&offset);
28378                                                 }
28379                                                 break;
28380 num_index_dim:
28381                                                 zend_hash_index_del(ht, hval);
28382                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28383                                                         zval_ptr_dtor(&offset);
28384                                                 }
28385                                                 break;
28386                                         case IS_NULL:
28387                                                 zend_hash_del(ht, "", sizeof(""));
28388                                                 break;
28389                                         default:
28390                                                 zend_error(E_WARNING, "Illegal offset type in unset");
28391                                                 break;
28392                                 }
28393                                 zval_ptr_dtor_nogc(&free_op2.var);
28394                                 break;
28395                         }
28396                         case IS_OBJECT:
28397                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
28398                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
28399                                 }
28400                                 if (0) {
28401                                         MAKE_REAL_ZVAL_PTR(offset);
28402                                 }
28403                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
28404                                 if (0) {
28405                                         zval_ptr_dtor(&offset);
28406                                 } else {
28407                                         zval_ptr_dtor_nogc(&free_op2.var);
28408                                 }
28409                                 break;
28410                         case IS_STRING:
28411                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
28412                                 ZEND_VM_CONTINUE(); /* bailed out before */
28413                         default:
28414                                 zval_ptr_dtor_nogc(&free_op2.var);
28415                                 break;
28416                 }
28417         } else {
28418                 zval_ptr_dtor_nogc(&free_op2.var);
28419         }
28420 
28421         CHECK_EXCEPTION();
28422         ZEND_VM_NEXT_OPCODE();
28423 }
28424 
28425 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28426 {
28427         USE_OPLINE
28428         zend_free_op free_op2;
28429         zval **container;
28430         zval *offset;
28431 
28432         SAVE_OPLINE();
28433         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28434         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28435 
28436         if (IS_UNUSED != IS_VAR || container) {
28437                 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
28438                         SEPARATE_ZVAL_IF_NOT_REF(container);
28439                 }
28440                 if (Z_TYPE_PP(container) == IS_OBJECT) {
28441                         if (0) {
28442                                 MAKE_REAL_ZVAL_PTR(offset);
28443                         }
28444                         if (Z_OBJ_HT_P(*container)->unset_property) {
28445                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28446                         } else {
28447                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
28448                         }
28449                         if (0) {
28450                                 zval_ptr_dtor(&offset);
28451                         } else {
28452                                 zval_ptr_dtor_nogc(&free_op2.var);
28453                         }
28454                 } else {
28455                         zval_ptr_dtor_nogc(&free_op2.var);
28456                 }
28457         } else {
28458                 zval_ptr_dtor_nogc(&free_op2.var);
28459         }
28460 
28461         CHECK_EXCEPTION();
28462         ZEND_VM_NEXT_OPCODE();
28463 }
28464 
28465 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
28466 {
28467         USE_OPLINE
28468         zend_free_op free_op2;
28469         zval *container;
28470         zval **value = NULL;
28471         int result = 0;
28472         ulong hval;
28473         zval *offset;
28474 
28475         SAVE_OPLINE();
28476         container = _get_obj_zval_ptr_unused(TSRMLS_C);
28477         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28478 
28479         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
28480                 HashTable *ht;
28481                 int isset = 0;
28482 
28483                 ht = Z_ARRVAL_P(container);
28484 
28485                 switch (Z_TYPE_P(offset)) {
28486                         case IS_DOUBLE:
28487                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
28488                                 goto num_index_prop;
28489                         case IS_RESOURCE:
28490                         case IS_BOOL:
28491                         case IS_LONG:
28492                                 hval = Z_LVAL_P(offset);
28493 num_index_prop:
28494                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
28495                                         isset = 1;
28496                                 }
28497                                 break;
28498                         case IS_STRING:
28499                                 if (IS_VAR == IS_CONST) {
28500                                         hval = Z_HASH_P(offset);
28501                                 } else {
28502                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
28503                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
28504                                 }
28505                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
28506                                         isset = 1;
28507                                 }
28508                                 break;
28509                         case IS_NULL:
28510                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
28511                                         isset = 1;
28512                                 }
28513                                 break;
28514                         default:
28515                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
28516                                 break;
28517                 }
28518 
28519                 if (opline->extended_value & ZEND_ISSET) {
28520                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
28521                                 result = 0;
28522                         } else {
28523                                 result = isset;
28524                         }
28525                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
28526                         if (!isset || !i_zend_is_true(*value)) {
28527                                 result = 0;
28528                         } else {
28529                                 result = 1;
28530                         }
28531                 }
28532                 zval_ptr_dtor_nogc(&free_op2.var);
28533         } else if (Z_TYPE_P(container) == IS_OBJECT) {
28534                 if (0) {
28535                         MAKE_REAL_ZVAL_PTR(offset);
28536                 }
28537                 if (prop_dim) {
28538                         if (Z_OBJ_HT_P(container)->has_property) {
28539                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28540                         } else {
28541                                 zend_error(E_NOTICE, "Trying to check property of non-object");
28542                                 result = 0;
28543                         }
28544                 } else {
28545                         if (Z_OBJ_HT_P(container)->has_dimension) {
28546                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
28547                         } else {
28548                                 zend_error(E_NOTICE, "Trying to check element of non-array");
28549                                 result = 0;
28550                         }
28551                 }
28552                 if (0) {
28553                         zval_ptr_dtor(&offset);
28554                 } else {
28555                         zval_ptr_dtor_nogc(&free_op2.var);
28556                 }
28557         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
28558                 zval tmp;
28559 
28560                 if (Z_TYPE_P(offset) != IS_LONG) {
28561                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
28562                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
28563                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
28564                                 ZVAL_COPY_VALUE(&tmp, offset);
28565                                 zval_copy_ctor(&tmp);
28566                                 convert_to_long(&tmp);
28567                                 offset = &tmp;
28568                         } else {
28569                                 /* can not be converted to proper offset, return "not set" */
28570                                 result = 0;
28571                         }
28572                 }
28573                 if (Z_TYPE_P(offset) == IS_LONG) {
28574                         if (opline->extended_value & ZEND_ISSET) {
28575                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
28576                                         result = 1;
28577                                 }
28578                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
28579                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
28580                                         result = 1;
28581                                 }
28582                         }
28583                 }
28584                 zval_ptr_dtor_nogc(&free_op2.var);
28585         } else {
28586                 zval_ptr_dtor_nogc(&free_op2.var);
28587         }
28588 
28589         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
28590         if (opline->extended_value & ZEND_ISSET) {
28591                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
28592         } else {
28593                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
28594         }
28595 
28596         CHECK_EXCEPTION();
28597         ZEND_VM_NEXT_OPCODE();
28598 }
28599 
28600 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28601 {
28602         return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28603 }
28604 
28605 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28606 {
28607         return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28608 }
28609 
28610 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28611 {
28612         USE_OPLINE
28613 
28614         /* The generator object is stored in return_value_ptr_ptr */
28615         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
28616 
28617         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
28618                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
28619         }
28620 
28621         /* Destroy the previously yielded value */
28622         if (generator->value) {
28623                 zval_ptr_dtor(&generator->value);
28624         }
28625 
28626         /* Destroy the previously yielded key */
28627         if (generator->key) {
28628                 zval_ptr_dtor(&generator->key);
28629         }
28630 
28631         /* Set the new yielded value */
28632         if (IS_UNUSED != IS_UNUSED) {
28633 
28634 
28635                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
28636                         /* Constants and temporary variables aren't yieldable by reference,
28637                          * but we still allow them with a notice. */
28638                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
28639                                 zval *value, *copy;
28640 
28641                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28642 
28643                                 value = NULL;
28644                                 ALLOC_ZVAL(copy);
28645                                 INIT_PZVAL_COPY(copy, value);
28646 
28647                                 /* Temporary variables don't need ctor copying */
28648                                 if (!0) {
28649                                         zval_copy_ctor(copy);
28650                                 }
28651 
28652                                 generator->value = copy;
28653                         } else {
28654                                 zval **value_ptr = NULL;
28655 
28656                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
28657                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
28658                                 }
28659 
28660                                 /* If a function call result is yielded and the function did
28661                                  * not return by reference we throw a notice. */
28662                                 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
28663                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
28664                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
28665                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
28666                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28667 
28668                                         Z_ADDREF_PP(value_ptr);
28669                                         generator->value = *value_ptr;
28670                                 } else {
28671                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
28672                                         Z_ADDREF_PP(value_ptr);
28673                                         generator->value = *value_ptr;
28674                                 }
28675 
28676                         }
28677                 } else {
28678                         zval *value = NULL;
28679 
28680                         /* Consts, temporary variables and references need copying */
28681                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
28682                                 || PZVAL_IS_REF(value)
28683                         ) {
28684                                 zval *copy;
28685 
28686                                 ALLOC_ZVAL(copy);
28687                                 INIT_PZVAL_COPY(copy, value);
28688 
28689                                 /* Temporary variables don't need ctor copying */
28690                                 if (!0) {
28691                                         zval_copy_ctor(copy);
28692                                 }
28693 
28694                                 generator->value = copy;
28695 
28696                         } else {
28697                                 if (IS_UNUSED == IS_CV) {
28698                                         Z_ADDREF_P(value);
28699                                 }
28700                                 generator->value = value;
28701                         }
28702                 }
28703         } else {
28704                 /* If no value was specified yield null */
28705                 Z_ADDREF(EG(uninitialized_zval));
28706                 generator->value = &EG(uninitialized_zval);
28707         }
28708 
28709         /* Set the new yielded key */
28710         if (IS_VAR != IS_UNUSED) {
28711                 zend_free_op free_op2;
28712                 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
28713 
28714                 /* Consts, temporary variables and references need copying */
28715                 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
28716                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
28717                 ) {
28718                         zval *copy;
28719 
28720                         ALLOC_ZVAL(copy);
28721                         INIT_PZVAL_COPY(copy, key);
28722 
28723                         /* Temporary variables don't need ctor copying */
28724                         if (!0) {
28725                                 zval_copy_ctor(copy);
28726                         }
28727 
28728                         generator->key = copy;
28729                 } else {
28730                         Z_ADDREF_P(key);
28731                         generator->key = key;
28732                 }
28733 
28734                 if (Z_TYPE_P(generator->key) == IS_LONG
28735                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
28736                 ) {
28737                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
28738                 }
28739 
28740                 zval_ptr_dtor_nogc(&free_op2.var);
28741         } else {
28742                 /* If no key was specified we use auto-increment keys */
28743                 generator->largest_used_integer_key++;
28744 
28745                 ALLOC_INIT_ZVAL(generator->key);
28746                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
28747         }
28748 
28749         if (RETURN_VALUE_USED(opline)) {
28750                 /* If the return value of yield is used set the send
28751                  * target and initialize it to NULL */
28752                 generator->send_target = &EX_T(opline->result.var).var.ptr;
28753                 Z_ADDREF(EG(uninitialized_zval));
28754                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28755         } else {
28756                 generator->send_target = NULL;
28757         }
28758 
28759         /* We increment to the next op, so we are at the correct position when the
28760          * generator is resumed. */
28761         ZEND_VM_INC_OPCODE();
28762 
28763         /* The GOTO VM uses a local opline variable. We need to set the opline
28764          * variable in execute_data so we don't resume at an old position. */
28765         SAVE_OPLINE();
28766 
28767         ZEND_VM_RETURN();
28768 }
28769 
28770 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28771 {
28772         return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28773 }
28774 
28775 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
28776 {
28777         USE_OPLINE
28778         zend_free_op free_op_data1;
28779         zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28780         zval *object;
28781         zval *property = NULL;
28782         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
28783         int have_get_ptr = 0;
28784 
28785         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
28786                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
28787         }
28788 
28789         make_real_object(object_ptr TSRMLS_CC);
28790         object = *object_ptr;
28791 
28792         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
28793                 zend_error(E_WARNING, "Attempt to assign property of non-object");
28794 
28795                 FREE_OP(free_op_data1);
28796 
28797                 if (RETURN_VALUE_USED(opline)) {
28798                         PZVAL_LOCK(&EG(uninitialized_zval));
28799                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28800                 }
28801         } else {
28802                 /* here we are sure we are dealing with an object */
28803                 if (0) {
28804                         MAKE_REAL_ZVAL_PTR(property);
28805                 }
28806 
28807                 /* here property is a string */
28808                 if (opline->extended_value == ZEND_ASSIGN_OBJ
28809                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
28810                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28811                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
28812                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
28813 
28814                                 have_get_ptr = 1;
28815                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
28816                                 if (RETURN_VALUE_USED(opline)) {
28817                                         PZVAL_LOCK(*zptr);
28818                                         EX_T(opline->result.var).var.ptr = *zptr;
28819                                 }
28820                         }
28821                 }
28822 
28823                 if (!have_get_ptr) {
28824                         zval *z = NULL;
28825 
28826                         Z_ADDREF_P(object);
28827                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
28828                                 if (Z_OBJ_HT_P(object)->read_property) {
28829                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28830                                 }
28831                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
28832                                 if (Z_OBJ_HT_P(object)->read_dimension) {
28833                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
28834                                 }
28835                         }
28836                         if (z) {
28837                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
28838                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
28839 
28840                                         if (Z_REFCOUNT_P(z) == 0) {
28841                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
28842                                                 zval_dtor(z);
28843                                                 FREE_ZVAL(z);
28844                                         }
28845                                         z = value;
28846                                 }
28847                                 Z_ADDREF_P(z);
28848                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
28849                                 binary_op(z, z, value TSRMLS_CC);
28850                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
28851                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
28852                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
28853                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
28854                                 }
28855                                 if (RETURN_VALUE_USED(opline)) {
28856                                         PZVAL_LOCK(z);
28857                                         EX_T(opline->result.var).var.ptr = z;
28858                                 }
28859                                 zval_ptr_dtor(&z);
28860                         } else {
28861                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
28862                                 if (RETURN_VALUE_USED(opline)) {
28863                                         PZVAL_LOCK(&EG(uninitialized_zval));
28864                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28865                                 }
28866                         }
28867                         zval_ptr_dtor(&object);
28868                 }
28869 
28870                 if (0) {
28871                         zval_ptr_dtor(&property);
28872                 } else {
28873 
28874                 }
28875                 FREE_OP(free_op_data1);
28876         }
28877 
28878         /* assign_obj has two opcodes! */
28879         CHECK_EXCEPTION();
28880         ZEND_VM_INC_OPCODE();
28881         ZEND_VM_NEXT_OPCODE();
28882 }
28883 
28884 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
28885 {
28886         USE_OPLINE
28887         zend_free_op free_op_data2, free_op_data1;
28888         zval **var_ptr;
28889         zval *value;
28890 
28891         SAVE_OPLINE();
28892         switch (opline->extended_value) {
28893                 case ZEND_ASSIGN_OBJ:
28894                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28895                         break;
28896                 case ZEND_ASSIGN_DIM: {
28897                                 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
28898 
28899                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
28900                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
28901                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
28902                                         if (IS_UNUSED == IS_VAR && !0) {
28903                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
28904                                         }
28905                                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28906                                 } else {
28907                                         zval *dim = NULL;
28908 
28909                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
28910                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
28911                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
28912                                 }
28913                         }
28914                         break;
28915                 default:
28916                         value = NULL;
28917                         var_ptr = NULL;
28918                         /* do nothing */
28919                         break;
28920         }
28921 
28922         if (UNEXPECTED(var_ptr == NULL)) {
28923                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
28924         }
28925 
28926         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
28927                 if (RETURN_VALUE_USED(opline)) {
28928                         PZVAL_LOCK(&EG(uninitialized_zval));
28929                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
28930                 }
28931 
28932 
28933                 CHECK_EXCEPTION();
28934                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
28935                         ZEND_VM_INC_OPCODE();
28936                 }
28937                 ZEND_VM_NEXT_OPCODE();
28938         }
28939 
28940         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
28941 
28942         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
28943            && Z_OBJ_HANDLER_PP(var_ptr, get)
28944            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
28945                 /* proxy object */
28946                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
28947                 Z_ADDREF_P(objval);
28948                 binary_op(objval, objval, value TSRMLS_CC);
28949                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
28950                 zval_ptr_dtor(&objval);
28951         } else {
28952                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
28953         }
28954 
28955         if (RETURN_VALUE_USED(opline)) {
28956                 PZVAL_LOCK(*var_ptr);
28957                 EX_T(opline->result.var).var.ptr = *var_ptr;
28958         }
28959 
28960         if (opline->extended_value == ZEND_ASSIGN_DIM) {
28961                 FREE_OP(free_op_data1);
28962                 FREE_OP_VAR_PTR(free_op_data2);
28963 
28964                 CHECK_EXCEPTION();
28965                 ZEND_VM_INC_OPCODE();
28966         } else {
28967 
28968                 CHECK_EXCEPTION();
28969         }
28970         ZEND_VM_NEXT_OPCODE();
28971 }
28972 
28973 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28974 {
28975         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28976 }
28977 
28978 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28979 {
28980         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28981 }
28982 
28983 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28984 {
28985         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28986 }
28987 
28988 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28989 {
28990         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28991 }
28992 
28993 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28994 {
28995         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
28996 }
28997 
28998 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28999 {
29000         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29001 }
29002 
29003 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29004 {
29005         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29006 }
29007 
29008 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29009 {
29010         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29011 }
29012 
29013 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29014 {
29015         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29016 }
29017 
29018 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29019 {
29020         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29021 }
29022 
29023 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29024 {
29025         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29026 }
29027 
29028 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29029 {
29030         USE_OPLINE
29031 
29032         array_init(&EX_T(opline->result.var).tmp_var);
29033         if (IS_UNUSED == IS_UNUSED) {
29034                 ZEND_VM_NEXT_OPCODE();
29035 #if 0 || IS_UNUSED != IS_UNUSED
29036         } else {
29037                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29038 #endif
29039         }
29040 }
29041 
29042 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29043 {
29044         USE_OPLINE
29045 
29046         /* The generator object is stored in return_value_ptr_ptr */
29047         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
29048 
29049         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
29050                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
29051         }
29052 
29053         /* Destroy the previously yielded value */
29054         if (generator->value) {
29055                 zval_ptr_dtor(&generator->value);
29056         }
29057 
29058         /* Destroy the previously yielded key */
29059         if (generator->key) {
29060                 zval_ptr_dtor(&generator->key);
29061         }
29062 
29063         /* Set the new yielded value */
29064         if (IS_UNUSED != IS_UNUSED) {
29065 
29066 
29067                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
29068                         /* Constants and temporary variables aren't yieldable by reference,
29069                          * but we still allow them with a notice. */
29070                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
29071                                 zval *value, *copy;
29072 
29073                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
29074 
29075                                 value = NULL;
29076                                 ALLOC_ZVAL(copy);
29077                                 INIT_PZVAL_COPY(copy, value);
29078 
29079                                 /* Temporary variables don't need ctor copying */
29080                                 if (!0) {
29081                                         zval_copy_ctor(copy);
29082                                 }
29083 
29084                                 generator->value = copy;
29085                         } else {
29086                                 zval **value_ptr = NULL;
29087 
29088                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
29089                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
29090                                 }
29091 
29092                                 /* If a function call result is yielded and the function did
29093                                  * not return by reference we throw a notice. */
29094                                 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
29095                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
29096                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
29097                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
29098                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
29099 
29100                                         Z_ADDREF_PP(value_ptr);
29101                                         generator->value = *value_ptr;
29102                                 } else {
29103                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
29104                                         Z_ADDREF_PP(value_ptr);
29105                                         generator->value = *value_ptr;
29106                                 }
29107 
29108                         }
29109                 } else {
29110                         zval *value = NULL;
29111 
29112                         /* Consts, temporary variables and references need copying */
29113                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
29114                                 || PZVAL_IS_REF(value)
29115                         ) {
29116                                 zval *copy;
29117 
29118                                 ALLOC_ZVAL(copy);
29119                                 INIT_PZVAL_COPY(copy, value);
29120 
29121                                 /* Temporary variables don't need ctor copying */
29122                                 if (!0) {
29123                                         zval_copy_ctor(copy);
29124                                 }
29125 
29126                                 generator->value = copy;
29127 
29128                         } else {
29129                                 if (IS_UNUSED == IS_CV) {
29130                                         Z_ADDREF_P(value);
29131                                 }
29132                                 generator->value = value;
29133                         }
29134                 }
29135         } else {
29136                 /* If no value was specified yield null */
29137                 Z_ADDREF(EG(uninitialized_zval));
29138                 generator->value = &EG(uninitialized_zval);
29139         }
29140 
29141         /* Set the new yielded key */
29142         if (IS_UNUSED != IS_UNUSED) {
29143 
29144                 zval *key = NULL;
29145 
29146                 /* Consts, temporary variables and references need copying */
29147                 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
29148                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
29149                 ) {
29150                         zval *copy;
29151 
29152                         ALLOC_ZVAL(copy);
29153                         INIT_PZVAL_COPY(copy, key);
29154 
29155                         /* Temporary variables don't need ctor copying */
29156                         if (!0) {
29157                                 zval_copy_ctor(copy);
29158                         }
29159 
29160                         generator->key = copy;
29161                 } else {
29162                         Z_ADDREF_P(key);
29163                         generator->key = key;
29164                 }
29165 
29166                 if (Z_TYPE_P(generator->key) == IS_LONG
29167                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
29168                 ) {
29169                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
29170                 }
29171 
29172         } else {
29173                 /* If no key was specified we use auto-increment keys */
29174                 generator->largest_used_integer_key++;
29175 
29176                 ALLOC_INIT_ZVAL(generator->key);
29177                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
29178         }
29179 
29180         if (RETURN_VALUE_USED(opline)) {
29181                 /* If the return value of yield is used set the send
29182                  * target and initialize it to NULL */
29183                 generator->send_target = &EX_T(opline->result.var).var.ptr;
29184                 Z_ADDREF(EG(uninitialized_zval));
29185                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29186         } else {
29187                 generator->send_target = NULL;
29188         }
29189 
29190         /* We increment to the next op, so we are at the correct position when the
29191          * generator is resumed. */
29192         ZEND_VM_INC_OPCODE();
29193 
29194         /* The GOTO VM uses a local opline variable. We need to set the opline
29195          * variable in execute_data so we don't resume at an old position. */
29196         SAVE_OPLINE();
29197 
29198         ZEND_VM_RETURN();
29199 }
29200 
29201 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29202 {
29203         return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29204 }
29205 
29206 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
29207 {
29208         USE_OPLINE
29209         zend_free_op free_op_data1;
29210         zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29211         zval *object;
29212         zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29213         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
29214         int have_get_ptr = 0;
29215 
29216         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
29217                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29218         }
29219 
29220         make_real_object(object_ptr TSRMLS_CC);
29221         object = *object_ptr;
29222 
29223         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
29224                 zend_error(E_WARNING, "Attempt to assign property of non-object");
29225 
29226                 FREE_OP(free_op_data1);
29227 
29228                 if (RETURN_VALUE_USED(opline)) {
29229                         PZVAL_LOCK(&EG(uninitialized_zval));
29230                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29231                 }
29232         } else {
29233                 /* here we are sure we are dealing with an object */
29234                 if (0) {
29235                         MAKE_REAL_ZVAL_PTR(property);
29236                 }
29237 
29238                 /* here property is a string */
29239                 if (opline->extended_value == ZEND_ASSIGN_OBJ
29240                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
29241                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29242                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
29243                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
29244 
29245                                 have_get_ptr = 1;
29246                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
29247                                 if (RETURN_VALUE_USED(opline)) {
29248                                         PZVAL_LOCK(*zptr);
29249                                         EX_T(opline->result.var).var.ptr = *zptr;
29250                                 }
29251                         }
29252                 }
29253 
29254                 if (!have_get_ptr) {
29255                         zval *z = NULL;
29256 
29257                         Z_ADDREF_P(object);
29258                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
29259                                 if (Z_OBJ_HT_P(object)->read_property) {
29260                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29261                                 }
29262                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
29263                                 if (Z_OBJ_HT_P(object)->read_dimension) {
29264                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
29265                                 }
29266                         }
29267                         if (z) {
29268                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
29269                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
29270 
29271                                         if (Z_REFCOUNT_P(z) == 0) {
29272                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
29273                                                 zval_dtor(z);
29274                                                 FREE_ZVAL(z);
29275                                         }
29276                                         z = value;
29277                                 }
29278                                 Z_ADDREF_P(z);
29279                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
29280                                 binary_op(z, z, value TSRMLS_CC);
29281                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
29282                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29283                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
29284                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
29285                                 }
29286                                 if (RETURN_VALUE_USED(opline)) {
29287                                         PZVAL_LOCK(z);
29288                                         EX_T(opline->result.var).var.ptr = z;
29289                                 }
29290                                 zval_ptr_dtor(&z);
29291                         } else {
29292                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
29293                                 if (RETURN_VALUE_USED(opline)) {
29294                                         PZVAL_LOCK(&EG(uninitialized_zval));
29295                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29296                                 }
29297                         }
29298                         zval_ptr_dtor(&object);
29299                 }
29300 
29301                 if (0) {
29302                         zval_ptr_dtor(&property);
29303                 } else {
29304 
29305                 }
29306                 FREE_OP(free_op_data1);
29307         }
29308 
29309         /* assign_obj has two opcodes! */
29310         CHECK_EXCEPTION();
29311         ZEND_VM_INC_OPCODE();
29312         ZEND_VM_NEXT_OPCODE();
29313 }
29314 
29315 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
29316 {
29317         USE_OPLINE
29318         zend_free_op free_op_data2, free_op_data1;
29319         zval **var_ptr;
29320         zval *value;
29321 
29322         SAVE_OPLINE();
29323         switch (opline->extended_value) {
29324                 case ZEND_ASSIGN_OBJ:
29325                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29326                         break;
29327                 case ZEND_ASSIGN_DIM: {
29328                                 zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29329 
29330                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29331                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29332                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
29333                                         if (IS_UNUSED == IS_VAR && !0) {
29334                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
29335                                         }
29336                                         return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29337                                 } else {
29338                                         zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29339 
29340                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
29341                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
29342                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
29343                                 }
29344                         }
29345                         break;
29346                 default:
29347                         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29348                         var_ptr = NULL;
29349                         /* do nothing */
29350                         break;
29351         }
29352 
29353         if (UNEXPECTED(var_ptr == NULL)) {
29354                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
29355         }
29356 
29357         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
29358                 if (RETURN_VALUE_USED(opline)) {
29359                         PZVAL_LOCK(&EG(uninitialized_zval));
29360                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29361                 }
29362 
29363 
29364                 CHECK_EXCEPTION();
29365                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
29366                         ZEND_VM_INC_OPCODE();
29367                 }
29368                 ZEND_VM_NEXT_OPCODE();
29369         }
29370 
29371         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
29372 
29373         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
29374            && Z_OBJ_HANDLER_PP(var_ptr, get)
29375            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
29376                 /* proxy object */
29377                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
29378                 Z_ADDREF_P(objval);
29379                 binary_op(objval, objval, value TSRMLS_CC);
29380                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
29381                 zval_ptr_dtor(&objval);
29382         } else {
29383                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
29384         }
29385 
29386         if (RETURN_VALUE_USED(opline)) {
29387                 PZVAL_LOCK(*var_ptr);
29388                 EX_T(opline->result.var).var.ptr = *var_ptr;
29389         }
29390 
29391         if (opline->extended_value == ZEND_ASSIGN_DIM) {
29392                 FREE_OP(free_op_data1);
29393                 FREE_OP_VAR_PTR(free_op_data2);
29394 
29395                 CHECK_EXCEPTION();
29396                 ZEND_VM_INC_OPCODE();
29397         } else {
29398 
29399                 CHECK_EXCEPTION();
29400         }
29401         ZEND_VM_NEXT_OPCODE();
29402 }
29403 
29404 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29405 {
29406         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29407 }
29408 
29409 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29410 {
29411         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29412 }
29413 
29414 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29415 {
29416         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29417 }
29418 
29419 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29420 {
29421         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29422 }
29423 
29424 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29425 {
29426         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29427 }
29428 
29429 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29430 {
29431         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29432 }
29433 
29434 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29435 {
29436         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29437 }
29438 
29439 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29440 {
29441         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29442 }
29443 
29444 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29445 {
29446         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29447 }
29448 
29449 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29450 {
29451         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29452 }
29453 
29454 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29455 {
29456         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29457 }
29458 
29459 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
29460 {
29461         USE_OPLINE
29462 
29463         zval **object_ptr;
29464         zval *object;
29465         zval *property;
29466         zval **retval;
29467         int have_get_ptr = 0;
29468 
29469         SAVE_OPLINE();
29470         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29471         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29472         retval = &EX_T(opline->result.var).var.ptr;
29473 
29474         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
29475                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
29476         }
29477 
29478         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
29479         object = *object_ptr;
29480 
29481         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
29482                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
29483 
29484                 if (RETURN_VALUE_USED(opline)) {
29485                         PZVAL_LOCK(&EG(uninitialized_zval));
29486                         *retval = &EG(uninitialized_zval);
29487                 }
29488 
29489                 CHECK_EXCEPTION();
29490                 ZEND_VM_NEXT_OPCODE();
29491         }
29492 
29493         /* here we are sure we are dealing with an object */
29494 
29495         if (0) {
29496                 MAKE_REAL_ZVAL_PTR(property);
29497         }
29498 
29499         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
29500                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29501                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
29502                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
29503 
29504                         have_get_ptr = 1;
29505                         incdec_op(*zptr);
29506                         if (RETURN_VALUE_USED(opline)) {
29507                                 *retval = *zptr;
29508                                 PZVAL_LOCK(*retval);
29509                         }
29510                 }
29511         }
29512 
29513         if (!have_get_ptr) {
29514                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
29515                         zval *z;
29516 
29517                         Z_ADDREF_P(object);
29518                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29519 
29520                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
29521                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
29522 
29523                                 if (Z_REFCOUNT_P(z) == 0) {
29524                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
29525                                         zval_dtor(z);
29526                                         FREE_ZVAL(z);
29527                                 }
29528                                 z = value;
29529                         }
29530                         Z_ADDREF_P(z);
29531                         SEPARATE_ZVAL_IF_NOT_REF(&z);
29532                         incdec_op(z);
29533                         *retval = z;
29534                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29535                         zval_ptr_dtor(&object);
29536                         SELECTIVE_PZVAL_LOCK(*retval, opline);
29537                         zval_ptr_dtor(&z);
29538                 } else {
29539                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
29540                         if (RETURN_VALUE_USED(opline)) {
29541                                 PZVAL_LOCK(&EG(uninitialized_zval));
29542                                 *retval = &EG(uninitialized_zval);
29543                         }
29544                 }
29545         }
29546 
29547         if (0) {
29548                 zval_ptr_dtor(&property);
29549         } else {
29550 
29551         }
29552 
29553         CHECK_EXCEPTION();
29554         ZEND_VM_NEXT_OPCODE();
29555 }
29556 
29557 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29558 {
29559         return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29560 }
29561 
29562 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29563 {
29564         return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29565 }
29566 
29567 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
29568 {
29569         USE_OPLINE
29570 
29571         zval **object_ptr;
29572         zval *object;
29573         zval *property;
29574         zval *retval;
29575         int have_get_ptr = 0;
29576 
29577         SAVE_OPLINE();
29578         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29579         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29580         retval = &EX_T(opline->result.var).tmp_var;
29581 
29582         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
29583                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
29584         }
29585 
29586         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
29587         object = *object_ptr;
29588 
29589         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
29590                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
29591 
29592                 ZVAL_NULL(retval);
29593 
29594                 CHECK_EXCEPTION();
29595                 ZEND_VM_NEXT_OPCODE();
29596         }
29597 
29598         /* here we are sure we are dealing with an object */
29599 
29600         if (0) {
29601                 MAKE_REAL_ZVAL_PTR(property);
29602         }
29603 
29604         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
29605                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29606                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
29607                         have_get_ptr = 1;
29608                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
29609 
29610                         ZVAL_COPY_VALUE(retval, *zptr);
29611                         zendi_zval_copy_ctor(*retval);
29612 
29613                         incdec_op(*zptr);
29614 
29615                 }
29616         }
29617 
29618         if (!have_get_ptr) {
29619                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
29620                         zval *z, *z_copy;
29621 
29622                         Z_ADDREF_P(object);
29623                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29624                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
29625                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
29626 
29627                                 if (Z_REFCOUNT_P(z) == 0) {
29628                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
29629                                         zval_dtor(z);
29630                                         FREE_ZVAL(z);
29631                                 }
29632                                 z = value;
29633                         }
29634                         ZVAL_COPY_VALUE(retval, z);
29635                         zendi_zval_copy_ctor(*retval);
29636                         ALLOC_ZVAL(z_copy);
29637                         INIT_PZVAL_COPY(z_copy, z);
29638                         zendi_zval_copy_ctor(*z_copy);
29639                         incdec_op(z_copy);
29640                         Z_ADDREF_P(z);
29641                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29642                         zval_ptr_dtor(&object);
29643                         zval_ptr_dtor(&z_copy);
29644                         zval_ptr_dtor(&z);
29645                 } else {
29646                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
29647                         ZVAL_NULL(retval);
29648                 }
29649         }
29650 
29651         if (0) {
29652                 zval_ptr_dtor(&property);
29653         } else {
29654 
29655         }
29656 
29657         CHECK_EXCEPTION();
29658         ZEND_VM_NEXT_OPCODE();
29659 }
29660 
29661 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29662 {
29663         return zend_post_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29664 }
29665 
29666 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29667 {
29668         return zend_post_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29669 }
29670 
29671 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS)
29672 {
29673         USE_OPLINE
29674 
29675         zval *container;
29676 
29677         zval *offset;
29678 
29679         SAVE_OPLINE();
29680         container = _get_obj_zval_ptr_unused(TSRMLS_C);
29681         offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29682 
29683         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
29684             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
29685                 zend_error(E_NOTICE, "Trying to get property of non-object");
29686                 PZVAL_LOCK(&EG(uninitialized_zval));
29687                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29688 
29689         } else {
29690                 zval *retval;
29691 
29692                 if (0) {
29693                         MAKE_REAL_ZVAL_PTR(offset);
29694                 }
29695 
29696                 /* here we are sure we are dealing with an object */
29697                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29698 
29699                 PZVAL_LOCK(retval);
29700                 EX_T(opline->result.var).var.ptr = retval;
29701 
29702                 if (0) {
29703                         zval_ptr_dtor(&offset);
29704                 } else {
29705 
29706                 }
29707         }
29708 
29709         CHECK_EXCEPTION();
29710         ZEND_VM_NEXT_OPCODE();
29711 }
29712 
29713 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29714 {
29715         return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29716 }
29717 
29718 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29719 {
29720         USE_OPLINE
29721         zend_free_op free_op1;
29722         zval *property;
29723         zval **container;
29724 
29725         SAVE_OPLINE();
29726         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29727 
29728         if (0) {
29729                 MAKE_REAL_ZVAL_PTR(property);
29730         }
29731         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29732         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29733                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29734         }
29735 
29736         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
29737         if (0) {
29738                 zval_ptr_dtor(&property);
29739         } else {
29740 
29741         }
29742         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
29743                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
29744         }
29745 
29746         /* We are going to assign the result by reference */
29747         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
29748                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
29749 
29750                 Z_DELREF_PP(retval_ptr);
29751                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
29752                 Z_ADDREF_PP(retval_ptr);
29753                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
29754                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
29755         }
29756 
29757         CHECK_EXCEPTION();
29758         ZEND_VM_NEXT_OPCODE();
29759 }
29760 
29761 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29762 {
29763         USE_OPLINE
29764         zend_free_op free_op1;
29765         zval *property;
29766         zval **container;
29767 
29768         SAVE_OPLINE();
29769         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29770         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29771 
29772         if (0) {
29773                 MAKE_REAL_ZVAL_PTR(property);
29774         }
29775         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29776                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29777         }
29778         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
29779         if (0) {
29780                 zval_ptr_dtor(&property);
29781         } else {
29782 
29783         }
29784         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
29785                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
29786         }
29787 
29788         CHECK_EXCEPTION();
29789         ZEND_VM_NEXT_OPCODE();
29790 }
29791 
29792 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29793 {
29794         USE_OPLINE
29795 
29796         zval *container;
29797 
29798         zval *offset;
29799 
29800         SAVE_OPLINE();
29801         container = _get_obj_zval_ptr_unused(TSRMLS_C);
29802         offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29803 
29804         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
29805             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
29806                 PZVAL_LOCK(&EG(uninitialized_zval));
29807                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
29808 
29809         } else {
29810                 zval *retval;
29811 
29812                 if (0) {
29813                         MAKE_REAL_ZVAL_PTR(offset);
29814                 }
29815 
29816                 /* here we are sure we are dealing with an object */
29817                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29818 
29819                 PZVAL_LOCK(retval);
29820                 EX_T(opline->result.var).var.ptr = retval;
29821 
29822                 if (0) {
29823                         zval_ptr_dtor(&offset);
29824                 } else {
29825 
29826                 }
29827         }
29828 
29829         CHECK_EXCEPTION();
29830         ZEND_VM_NEXT_OPCODE();
29831 }
29832 
29833 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29834 {
29835         USE_OPLINE
29836 
29837         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
29838                 /* Behave like FETCH_OBJ_W */
29839                 zend_free_op free_op1;
29840                 zval *property;
29841                 zval **container;
29842 
29843                 SAVE_OPLINE();
29844                 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29845                 container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29846 
29847                 if (0) {
29848                         MAKE_REAL_ZVAL_PTR(property);
29849                 }
29850                 if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29851                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29852                 }
29853                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
29854                 if (0) {
29855                         zval_ptr_dtor(&property);
29856                 } else {
29857 
29858                 }
29859                 if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
29860                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
29861                 }
29862 
29863                 CHECK_EXCEPTION();
29864                 ZEND_VM_NEXT_OPCODE();
29865         } else {
29866                 return zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
29867         }
29868 }
29869 
29870 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29871 {
29872         USE_OPLINE
29873         zend_free_op free_op1, free_res;
29874         zval **container;
29875         zval *property;
29876 
29877         SAVE_OPLINE();
29878         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29879         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29880 
29881         if (IS_UNUSED == IS_CV) {
29882                 if (container != &EG(uninitialized_zval_ptr)) {
29883                         SEPARATE_ZVAL_IF_NOT_REF(container);
29884                 }
29885         }
29886         if (0) {
29887                 MAKE_REAL_ZVAL_PTR(property);
29888         }
29889         if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
29890                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
29891         }
29892         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
29893         if (0) {
29894                 zval_ptr_dtor(&property);
29895         } else {
29896 
29897         }
29898         if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
29899                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
29900         }
29901 
29902         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
29903         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
29904                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
29905         }
29906         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
29907         FREE_OP_VAR_PTR(free_res);
29908         CHECK_EXCEPTION();
29909         ZEND_VM_NEXT_OPCODE();
29910 }
29911 
29912 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29913 {
29914         USE_OPLINE
29915 
29916         zval **object_ptr;
29917         zval *property_name;
29918 
29919         SAVE_OPLINE();
29920         object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
29921         property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29922 
29923         if (0) {
29924                 MAKE_REAL_ZVAL_PTR(property_name);
29925         }
29926         if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
29927                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
29928         }
29929         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
29930         if (0) {
29931                 zval_ptr_dtor(&property_name);
29932         } else {
29933 
29934         }
29935 
29936         /* assign_obj has two opcodes! */
29937         CHECK_EXCEPTION();
29938         ZEND_VM_INC_OPCODE();
29939         ZEND_VM_NEXT_OPCODE();
29940 }
29941 
29942 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29943 {
29944         USE_OPLINE
29945 
29946         zval *str = &EX_T(opline->result.var).tmp_var;
29947         zval *var;
29948         zval var_copy;
29949         int use_copy = 0;
29950 
29951         SAVE_OPLINE();
29952         var = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29953 
29954         if (IS_UNUSED == IS_UNUSED) {
29955                 /* Initialize for erealloc in add_string_to_string */
29956                 Z_STRVAL_P(str) = NULL;
29957                 Z_STRLEN_P(str) = 0;
29958                 Z_TYPE_P(str) = IS_STRING;
29959 
29960                 INIT_PZVAL(str);
29961         }
29962 
29963         if (Z_TYPE_P(var) != IS_STRING) {
29964                 zend_make_printable_zval(var, &var_copy, &use_copy);
29965 
29966                 if (use_copy) {
29967                         var = &var_copy;
29968                 }
29969         }
29970         add_string_to_string(str, str, var);
29971 
29972         if (use_copy) {
29973                 zval_dtor(var);
29974         }
29975         /* original comment, possibly problematic:
29976          * FREE_OP is missing intentionally here - we're always working on the same temporary variable
29977          * (Zeev):  I don't think it's problematic, we only use variables
29978          * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
29979          * string offsets or overloaded objects
29980          */
29981 
29982         CHECK_EXCEPTION();
29983         ZEND_VM_NEXT_OPCODE();
29984 }
29985 
29986 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29987 {
29988         USE_OPLINE
29989         zval *function_name;
29990         char *function_name_strval;
29991         int function_name_strlen;
29992 
29993         call_slot *call = EX(call_slots) + opline->result.num;
29994 
29995         SAVE_OPLINE();
29996 
29997         function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
29998 
29999         if (IS_CV != IS_CONST &&
30000             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
30001                 if (UNEXPECTED(EG(exception) != NULL)) {
30002                         HANDLE_EXCEPTION();
30003                 }
30004                 zend_error_noreturn(E_ERROR, "Method name must be a string");
30005         }
30006 
30007         function_name_strval = Z_STRVAL_P(function_name);
30008         function_name_strlen = Z_STRLEN_P(function_name);
30009 
30010         call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
30011 
30012         if (EXPECTED(call->object != NULL) &&
30013             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
30014                 call->called_scope = Z_OBJCE_P(call->object);
30015 
30016                 if (IS_CV != IS_CONST ||
30017                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
30018                     zval *object = call->object;
30019 
30020                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
30021                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
30022                         }
30023 
30024                         /* First, locate the function. */
30025                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
30026                         if (UNEXPECTED(call->fbc == NULL)) {
30027                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
30028                         }
30029                         if (IS_CV == IS_CONST &&
30030                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
30031                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
30032                             EXPECTED(call->object == object)) {
30033                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
30034                         }
30035                 }
30036         } else {
30037                 if (UNEXPECTED(EG(exception) != NULL)) {
30038 
30039                         HANDLE_EXCEPTION();
30040                 }
30041                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
30042         }
30043 
30044         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
30045                 call->object = NULL;
30046         } else {
30047                 if (!PZVAL_IS_REF(call->object)) {
30048                         Z_ADDREF_P(call->object); /* For $this pointer */
30049                 } else {
30050                         zval *this_ptr;
30051                         ALLOC_ZVAL(this_ptr);
30052                         INIT_PZVAL_COPY(this_ptr, call->object);
30053                         zval_copy_ctor(this_ptr);
30054                         call->object = this_ptr;
30055                 }
30056         }
30057 
30058         call->num_additional_args = 0;
30059         call->is_ctor_call = 0;
30060         EX(call) = call;
30061 
30062 
30063         CHECK_EXCEPTION();
30064         ZEND_VM_NEXT_OPCODE();
30065 }
30066 
30067 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30068 {
30069         USE_OPLINE
30070 
30071         array_init(&EX_T(opline->result.var).tmp_var);
30072         if (IS_UNUSED == IS_UNUSED) {
30073                 ZEND_VM_NEXT_OPCODE();
30074 #if 0 || IS_UNUSED != IS_UNUSED
30075         } else {
30076                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30077 #endif
30078         }
30079 }
30080 
30081 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30082 {
30083         USE_OPLINE
30084 
30085         zval **container;
30086         zval *offset;
30087         ulong hval;
30088 
30089         SAVE_OPLINE();
30090         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
30091         if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
30092                 SEPARATE_ZVAL_IF_NOT_REF(container);
30093         }
30094         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30095 
30096         if (IS_UNUSED != IS_VAR || container) {
30097                 switch (Z_TYPE_PP(container)) {
30098                         case IS_ARRAY: {
30099                                 HashTable *ht = Z_ARRVAL_PP(container);
30100 
30101                                 switch (Z_TYPE_P(offset)) {
30102                                         case IS_DOUBLE:
30103                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
30104                                                 zend_hash_index_del(ht, hval);
30105                                                 break;
30106                                         case IS_RESOURCE:
30107                                         case IS_BOOL:
30108                                         case IS_LONG:
30109                                                 hval = Z_LVAL_P(offset);
30110                                                 zend_hash_index_del(ht, hval);
30111                                                 break;
30112                                         case IS_STRING:
30113                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
30114                                                         Z_ADDREF_P(offset);
30115                                                 }
30116                                                 if (IS_CV == IS_CONST) {
30117                                                         hval = Z_HASH_P(offset);
30118                                                 } else {
30119                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
30120                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
30121                                                 }
30122                                                 if (ht == &EG(symbol_table)) {
30123                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
30124                                                 } else {
30125                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
30126                                                 }
30127                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
30128                                                         zval_ptr_dtor(&offset);
30129                                                 }
30130                                                 break;
30131 num_index_dim:
30132                                                 zend_hash_index_del(ht, hval);
30133                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
30134                                                         zval_ptr_dtor(&offset);
30135                                                 }
30136                                                 break;
30137                                         case IS_NULL:
30138                                                 zend_hash_del(ht, "", sizeof(""));
30139                                                 break;
30140                                         default:
30141                                                 zend_error(E_WARNING, "Illegal offset type in unset");
30142                                                 break;
30143                                 }
30144 
30145                                 break;
30146                         }
30147                         case IS_OBJECT:
30148                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
30149                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
30150                                 }
30151                                 if (0) {
30152                                         MAKE_REAL_ZVAL_PTR(offset);
30153                                 }
30154                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
30155                                 if (0) {
30156                                         zval_ptr_dtor(&offset);
30157                                 } else {
30158 
30159                                 }
30160                                 break;
30161                         case IS_STRING:
30162                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
30163                                 ZEND_VM_CONTINUE(); /* bailed out before */
30164                         default:
30165 
30166                                 break;
30167                 }
30168         } else {
30169 
30170         }
30171 
30172         CHECK_EXCEPTION();
30173         ZEND_VM_NEXT_OPCODE();
30174 }
30175 
30176 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30177 {
30178         USE_OPLINE
30179 
30180         zval **container;
30181         zval *offset;
30182 
30183         SAVE_OPLINE();
30184         container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
30185         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30186 
30187         if (IS_UNUSED != IS_VAR || container) {
30188                 if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
30189                         SEPARATE_ZVAL_IF_NOT_REF(container);
30190                 }
30191                 if (Z_TYPE_PP(container) == IS_OBJECT) {
30192                         if (0) {
30193                                 MAKE_REAL_ZVAL_PTR(offset);
30194                         }
30195                         if (Z_OBJ_HT_P(*container)->unset_property) {
30196                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
30197                         } else {
30198                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
30199                         }
30200                         if (0) {
30201                                 zval_ptr_dtor(&offset);
30202                         } else {
30203 
30204                         }
30205                 } else {
30206 
30207                 }
30208         } else {
30209 
30210         }
30211 
30212         CHECK_EXCEPTION();
30213         ZEND_VM_NEXT_OPCODE();
30214 }
30215 
30216 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
30217 {
30218         USE_OPLINE
30219 
30220         zval *container;
30221         zval **value = NULL;
30222         int result = 0;
30223         ulong hval;
30224         zval *offset;
30225 
30226         SAVE_OPLINE();
30227         container = _get_obj_zval_ptr_unused(TSRMLS_C);
30228         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30229 
30230         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
30231                 HashTable *ht;
30232                 int isset = 0;
30233 
30234                 ht = Z_ARRVAL_P(container);
30235 
30236                 switch (Z_TYPE_P(offset)) {
30237                         case IS_DOUBLE:
30238                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
30239                                 goto num_index_prop;
30240                         case IS_RESOURCE:
30241                         case IS_BOOL:
30242                         case IS_LONG:
30243                                 hval = Z_LVAL_P(offset);
30244 num_index_prop:
30245                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
30246                                         isset = 1;
30247                                 }
30248                                 break;
30249                         case IS_STRING:
30250                                 if (IS_CV == IS_CONST) {
30251                                         hval = Z_HASH_P(offset);
30252                                 } else {
30253                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
30254                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
30255                                 }
30256                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
30257                                         isset = 1;
30258                                 }
30259                                 break;
30260                         case IS_NULL:
30261                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
30262                                         isset = 1;
30263                                 }
30264                                 break;
30265                         default:
30266                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
30267                                 break;
30268                 }
30269 
30270                 if (opline->extended_value & ZEND_ISSET) {
30271                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
30272                                 result = 0;
30273                         } else {
30274                                 result = isset;
30275                         }
30276                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
30277                         if (!isset || !i_zend_is_true(*value)) {
30278                                 result = 0;
30279                         } else {
30280                                 result = 1;
30281                         }
30282                 }
30283 
30284         } else if (Z_TYPE_P(container) == IS_OBJECT) {
30285                 if (0) {
30286                         MAKE_REAL_ZVAL_PTR(offset);
30287                 }
30288                 if (prop_dim) {
30289                         if (Z_OBJ_HT_P(container)->has_property) {
30290                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
30291                         } else {
30292                                 zend_error(E_NOTICE, "Trying to check property of non-object");
30293                                 result = 0;
30294                         }
30295                 } else {
30296                         if (Z_OBJ_HT_P(container)->has_dimension) {
30297                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
30298                         } else {
30299                                 zend_error(E_NOTICE, "Trying to check element of non-array");
30300                                 result = 0;
30301                         }
30302                 }
30303                 if (0) {
30304                         zval_ptr_dtor(&offset);
30305                 } else {
30306 
30307                 }
30308         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
30309                 zval tmp;
30310 
30311                 if (Z_TYPE_P(offset) != IS_LONG) {
30312                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
30313                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
30314                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
30315                                 ZVAL_COPY_VALUE(&tmp, offset);
30316                                 zval_copy_ctor(&tmp);
30317                                 convert_to_long(&tmp);
30318                                 offset = &tmp;
30319                         } else {
30320                                 /* can not be converted to proper offset, return "not set" */
30321                                 result = 0;
30322                         }
30323                 }
30324                 if (Z_TYPE_P(offset) == IS_LONG) {
30325                         if (opline->extended_value & ZEND_ISSET) {
30326                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
30327                                         result = 1;
30328                                 }
30329                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
30330                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
30331                                         result = 1;
30332                                 }
30333                         }
30334                 }
30335 
30336         } else {
30337 
30338         }
30339 
30340         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
30341         if (opline->extended_value & ZEND_ISSET) {
30342                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
30343         } else {
30344                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
30345         }
30346 
30347         CHECK_EXCEPTION();
30348         ZEND_VM_NEXT_OPCODE();
30349 }
30350 
30351 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30352 {
30353         return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30354 }
30355 
30356 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30357 {
30358         return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30359 }
30360 
30361 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30362 {
30363         USE_OPLINE
30364 
30365         /* The generator object is stored in return_value_ptr_ptr */
30366         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
30367 
30368         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
30369                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
30370         }
30371 
30372         /* Destroy the previously yielded value */
30373         if (generator->value) {
30374                 zval_ptr_dtor(&generator->value);
30375         }
30376 
30377         /* Destroy the previously yielded key */
30378         if (generator->key) {
30379                 zval_ptr_dtor(&generator->key);
30380         }
30381 
30382         /* Set the new yielded value */
30383         if (IS_UNUSED != IS_UNUSED) {
30384 
30385 
30386                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
30387                         /* Constants and temporary variables aren't yieldable by reference,
30388                          * but we still allow them with a notice. */
30389                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
30390                                 zval *value, *copy;
30391 
30392                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30393 
30394                                 value = NULL;
30395                                 ALLOC_ZVAL(copy);
30396                                 INIT_PZVAL_COPY(copy, value);
30397 
30398                                 /* Temporary variables don't need ctor copying */
30399                                 if (!0) {
30400                                         zval_copy_ctor(copy);
30401                                 }
30402 
30403                                 generator->value = copy;
30404                         } else {
30405                                 zval **value_ptr = NULL;
30406 
30407                                 if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
30408                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
30409                                 }
30410 
30411                                 /* If a function call result is yielded and the function did
30412                                  * not return by reference we throw a notice. */
30413                                 if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
30414                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
30415                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
30416                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
30417                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30418 
30419                                         Z_ADDREF_PP(value_ptr);
30420                                         generator->value = *value_ptr;
30421                                 } else {
30422                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
30423                                         Z_ADDREF_PP(value_ptr);
30424                                         generator->value = *value_ptr;
30425                                 }
30426 
30427                         }
30428                 } else {
30429                         zval *value = NULL;
30430 
30431                         /* Consts, temporary variables and references need copying */
30432                         if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
30433                                 || PZVAL_IS_REF(value)
30434                         ) {
30435                                 zval *copy;
30436 
30437                                 ALLOC_ZVAL(copy);
30438                                 INIT_PZVAL_COPY(copy, value);
30439 
30440                                 /* Temporary variables don't need ctor copying */
30441                                 if (!0) {
30442                                         zval_copy_ctor(copy);
30443                                 }
30444 
30445                                 generator->value = copy;
30446 
30447                         } else {
30448                                 if (IS_UNUSED == IS_CV) {
30449                                         Z_ADDREF_P(value);
30450                                 }
30451                                 generator->value = value;
30452                         }
30453                 }
30454         } else {
30455                 /* If no value was specified yield null */
30456                 Z_ADDREF(EG(uninitialized_zval));
30457                 generator->value = &EG(uninitialized_zval);
30458         }
30459 
30460         /* Set the new yielded key */
30461         if (IS_CV != IS_UNUSED) {
30462 
30463                 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
30464 
30465                 /* Consts, temporary variables and references need copying */
30466                 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
30467                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
30468                 ) {
30469                         zval *copy;
30470 
30471                         ALLOC_ZVAL(copy);
30472                         INIT_PZVAL_COPY(copy, key);
30473 
30474                         /* Temporary variables don't need ctor copying */
30475                         if (!0) {
30476                                 zval_copy_ctor(copy);
30477                         }
30478 
30479                         generator->key = copy;
30480                 } else {
30481                         Z_ADDREF_P(key);
30482                         generator->key = key;
30483                 }
30484 
30485                 if (Z_TYPE_P(generator->key) == IS_LONG
30486                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
30487                 ) {
30488                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
30489                 }
30490 
30491         } else {
30492                 /* If no key was specified we use auto-increment keys */
30493                 generator->largest_used_integer_key++;
30494 
30495                 ALLOC_INIT_ZVAL(generator->key);
30496                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
30497         }
30498 
30499         if (RETURN_VALUE_USED(opline)) {
30500                 /* If the return value of yield is used set the send
30501                  * target and initialize it to NULL */
30502                 generator->send_target = &EX_T(opline->result.var).var.ptr;
30503                 Z_ADDREF(EG(uninitialized_zval));
30504                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
30505         } else {
30506                 generator->send_target = NULL;
30507         }
30508 
30509         /* We increment to the next op, so we are at the correct position when the
30510          * generator is resumed. */
30511         ZEND_VM_INC_OPCODE();
30512 
30513         /* The GOTO VM uses a local opline variable. We need to set the opline
30514          * variable in execute_data so we don't resume at an old position. */
30515         SAVE_OPLINE();
30516 
30517         ZEND_VM_RETURN();
30518 }
30519 
30520 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30521 {
30522         return zend_binary_assign_op_helper_SPEC_UNUSED_CV(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30523 }
30524 
30525 static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30526 {
30527         USE_OPLINE
30528 
30529 
30530         SAVE_OPLINE();
30531         bitwise_not_function(&EX_T(opline->result.var).tmp_var,
30532                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
30533 
30534         CHECK_EXCEPTION();
30535         ZEND_VM_NEXT_OPCODE();
30536 }
30537 
30538 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30539 {
30540         USE_OPLINE
30541 
30542 
30543         SAVE_OPLINE();
30544         boolean_not_function(&EX_T(opline->result.var).tmp_var,
30545                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
30546 
30547         CHECK_EXCEPTION();
30548         ZEND_VM_NEXT_OPCODE();
30549 }
30550 
30551 static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30552 {
30553         USE_OPLINE
30554 
30555         zval **var_ptr;
30556 
30557         SAVE_OPLINE();
30558         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
30559 
30560         if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
30561                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
30562         }
30563         if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
30564                 if (RETURN_VALUE_USED(opline)) {
30565                         PZVAL_LOCK(&EG(uninitialized_zval));
30566                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
30567                 }
30568 
30569                 CHECK_EXCEPTION();
30570                 ZEND_VM_NEXT_OPCODE();
30571         }
30572 
30573         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
30574 
30575         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
30576            && Z_OBJ_HANDLER_PP(var_ptr, get)
30577            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
30578                 /* proxy object */
30579                 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
30580                 Z_ADDREF_P(val);
30581                 fast_increment_function(val);
30582                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
30583                 zval_ptr_dtor(&val);
30584         } else {
30585                 fast_increment_function(*var_ptr);
30586         }
30587 
30588         if (RETURN_VALUE_USED(opline)) {
30589                 PZVAL_LOCK(*var_ptr);
30590                 EX_T(opline->result.var).var.ptr = *var_ptr;
30591         }
30592 
30593         CHECK_EXCEPTION();
30594         ZEND_VM_NEXT_OPCODE();
30595 }
30596 
30597 static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30598 {
30599         USE_OPLINE
30600 
30601         zval **var_ptr;
30602 
30603         SAVE_OPLINE();
30604         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
30605 
30606         if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
30607                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
30608         }
30609         if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
30610                 if (RETURN_VALUE_USED(opline)) {
30611                         PZVAL_LOCK(&EG(uninitialized_zval));
30612                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
30613                 }
30614 
30615                 CHECK_EXCEPTION();
30616                 ZEND_VM_NEXT_OPCODE();
30617         }
30618 
30619         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
30620 
30621         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
30622            && Z_OBJ_HANDLER_PP(var_ptr, get)
30623            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
30624                 /* proxy object */
30625                 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
30626                 Z_ADDREF_P(val);
30627                 fast_decrement_function(val);
30628                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
30629                 zval_ptr_dtor(&val);
30630         } else {
30631                 fast_decrement_function(*var_ptr);
30632         }
30633 
30634         if (RETURN_VALUE_USED(opline)) {
30635                 PZVAL_LOCK(*var_ptr);
30636                 EX_T(opline->result.var).var.ptr = *var_ptr;
30637         }
30638 
30639         CHECK_EXCEPTION();
30640         ZEND_VM_NEXT_OPCODE();
30641 }
30642 
30643 static int ZEND_FASTCALL  ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30644 {
30645         USE_OPLINE
30646 
30647         zval **var_ptr, *retval;
30648 
30649         SAVE_OPLINE();
30650         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
30651 
30652         if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
30653                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
30654         }
30655         if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
30656                 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
30657 
30658                 CHECK_EXCEPTION();
30659                 ZEND_VM_NEXT_OPCODE();
30660         }
30661 
30662         retval = &EX_T(opline->result.var).tmp_var;
30663         ZVAL_COPY_VALUE(retval, *var_ptr);
30664         zendi_zval_copy_ctor(*retval);
30665 
30666         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
30667 
30668         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
30669            && Z_OBJ_HANDLER_PP(var_ptr, get)
30670            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
30671                 /* proxy object */
30672                 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
30673                 Z_ADDREF_P(val);
30674                 fast_increment_function(val);
30675                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
30676                 zval_ptr_dtor(&val);
30677         } else {
30678                 fast_increment_function(*var_ptr);
30679         }
30680 
30681         CHECK_EXCEPTION();
30682         ZEND_VM_NEXT_OPCODE();
30683 }
30684 
30685 static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30686 {
30687         USE_OPLINE
30688 
30689         zval **var_ptr, *retval;
30690 
30691         SAVE_OPLINE();
30692         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
30693 
30694         if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
30695                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
30696         }
30697         if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
30698                 ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
30699 
30700                 CHECK_EXCEPTION();
30701                 ZEND_VM_NEXT_OPCODE();
30702         }
30703 
30704         retval = &EX_T(opline->result.var).tmp_var;
30705         ZVAL_COPY_VALUE(retval, *var_ptr);
30706         zendi_zval_copy_ctor(*retval);
30707 
30708         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
30709 
30710         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
30711            && Z_OBJ_HANDLER_PP(var_ptr, get)
30712            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
30713                 /* proxy object */
30714                 zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
30715                 Z_ADDREF_P(val);
30716                 fast_decrement_function(val);
30717                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
30718                 zval_ptr_dtor(&val);
30719         } else {
30720                 fast_decrement_function(*var_ptr);
30721         }
30722 
30723         CHECK_EXCEPTION();
30724         ZEND_VM_NEXT_OPCODE();
30725 }
30726 
30727 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30728 {
30729         USE_OPLINE
30730 
30731         zval *z;
30732 
30733         SAVE_OPLINE();
30734         z = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30735 
30736         if (IS_CV == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
30737                 INIT_PZVAL(z);
30738         }
30739         zend_print_variable(z);
30740 
30741         CHECK_EXCEPTION();
30742         ZEND_VM_NEXT_OPCODE();
30743 }
30744 
30745 static int ZEND_FASTCALL  ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30746 {
30747         USE_OPLINE
30748 
30749         ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
30750         return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30751 }
30752 
30753 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30754 {
30755         USE_OPLINE
30756 
30757         zval *val;
30758         int ret;
30759 
30760         SAVE_OPLINE();
30761         val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30762 
30763         if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
30764                 ret = Z_LVAL_P(val);
30765         } else {
30766                 ret = i_zend_is_true(val);
30767 
30768                 if (UNEXPECTED(EG(exception) != NULL)) {
30769                         HANDLE_EXCEPTION();
30770                 }
30771         }
30772         if (!ret) {
30773 #if DEBUG_ZEND>=2
30774                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
30775 #endif
30776                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
30777                 ZEND_VM_CONTINUE();
30778         }
30779 
30780         ZEND_VM_NEXT_OPCODE();
30781 }
30782 
30783 static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30784 {
30785         USE_OPLINE
30786 
30787         zval *val;
30788         int ret;
30789 
30790         SAVE_OPLINE();
30791         val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30792 
30793         if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
30794                 ret = Z_LVAL_P(val);
30795         } else {
30796                 ret = i_zend_is_true(val);
30797 
30798                 if (UNEXPECTED(EG(exception) != NULL)) {
30799                         HANDLE_EXCEPTION();
30800                 }
30801         }
30802         if (ret) {
30803 #if DEBUG_ZEND>=2
30804                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
30805 #endif
30806                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
30807                 ZEND_VM_CONTINUE();
30808         }
30809 
30810         ZEND_VM_NEXT_OPCODE();
30811 }
30812 
30813 static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30814 {
30815         USE_OPLINE
30816 
30817         zval *val;
30818         int retval;
30819 
30820         SAVE_OPLINE();
30821         val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30822 
30823         if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
30824                 retval = Z_LVAL_P(val);
30825         } else {
30826                 retval = i_zend_is_true(val);
30827 
30828                 if (UNEXPECTED(EG(exception) != NULL)) {
30829                         HANDLE_EXCEPTION();
30830                 }
30831         }
30832         if (EXPECTED(retval != 0)) {
30833 #if DEBUG_ZEND>=2
30834                 printf("Conditional jmp on true to %d\n", opline->extended_value);
30835 #endif
30836                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
30837                 ZEND_VM_CONTINUE(); /* CHECK_ME */
30838         } else {
30839 #if DEBUG_ZEND>=2
30840                 printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
30841 #endif
30842                 ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
30843                 ZEND_VM_CONTINUE(); /* CHECK_ME */
30844         }
30845 }
30846 
30847 static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30848 {
30849         USE_OPLINE
30850 
30851         zval *val;
30852         int retval;
30853 
30854         SAVE_OPLINE();
30855         val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30856 
30857         if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
30858                 retval = Z_LVAL_P(val);
30859         } else {
30860                 retval = i_zend_is_true(val);
30861 
30862                 if (UNEXPECTED(EG(exception) != NULL)) {
30863                         HANDLE_EXCEPTION();
30864                 }
30865         }
30866         Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
30867         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
30868         if (!retval) {
30869 #if DEBUG_ZEND>=2
30870                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
30871 #endif
30872                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
30873                 ZEND_VM_CONTINUE();
30874         }
30875         ZEND_VM_NEXT_OPCODE();
30876 }
30877 
30878 static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30879 {
30880         USE_OPLINE
30881 
30882         zval *val;
30883         int retval;
30884 
30885         SAVE_OPLINE();
30886         val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30887 
30888         if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
30889                 retval = Z_LVAL_P(val);
30890         } else {
30891                 retval = i_zend_is_true(val);
30892 
30893                 if (UNEXPECTED(EG(exception) != NULL)) {
30894                         HANDLE_EXCEPTION();
30895                 }
30896         }
30897         Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
30898         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
30899         if (retval) {
30900 #if DEBUG_ZEND>=2
30901                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
30902 #endif
30903                 ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
30904                 ZEND_VM_CONTINUE();
30905         }
30906         ZEND_VM_NEXT_OPCODE();
30907 }
30908 
30909 static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30910 {
30911         USE_OPLINE
30912         zval *retval_ptr;
30913 
30914 
30915         SAVE_OPLINE();
30916         retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30917 
30918         if (!EG(return_value_ptr_ptr)) {
30919 
30920         } else {
30921                 if (IS_CV == IS_CONST ||
30922                     IS_CV == IS_TMP_VAR ||
30923                     PZVAL_IS_REF(retval_ptr)) {
30924                         zval *ret;
30925 
30926                         ALLOC_ZVAL(ret);
30927                         INIT_PZVAL_COPY(ret, retval_ptr);
30928                         if (IS_CV != IS_TMP_VAR) {
30929                                 zval_copy_ctor(ret);
30930                         }
30931                         *EG(return_value_ptr_ptr) = ret;
30932 
30933                 } else if ((IS_CV == IS_CV || IS_CV == IS_VAR) &&
30934                            retval_ptr == &EG(uninitialized_zval)) {
30935                         zval *ret;
30936 
30937                         if (IS_CV == IS_VAR) {
30938                                 Z_DELREF_P(retval_ptr);
30939                         }
30940                         ALLOC_INIT_ZVAL(ret);
30941                         *EG(return_value_ptr_ptr) = ret;
30942                 } else {
30943                         *EG(return_value_ptr_ptr) = retval_ptr;
30944                         if (IS_CV == IS_CV) {
30945                                 Z_ADDREF_P(retval_ptr);
30946                         }
30947                 }
30948         }
30949         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
30950 }
30951 
30952 static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30953 {
30954         USE_OPLINE
30955         zval *retval_ptr;
30956         zval **retval_ptr_ptr;
30957 
30958 
30959         SAVE_OPLINE();
30960 
30961         do {
30962                 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR ||
30963                     (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
30964                         /* Not supposed to happen, but we'll allow it */
30965                         zend_error(E_NOTICE, "Only variable references should be returned by reference");
30966 
30967                         retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
30968                         if (!EG(return_value_ptr_ptr)) {
30969                                 if (IS_CV == IS_TMP_VAR) {
30970 
30971                                 }
30972                         } else if (!0) { /* Not a temp var */
30973                                 zval *ret;
30974 
30975                                 ALLOC_ZVAL(ret);
30976                                 INIT_PZVAL_COPY(ret, retval_ptr);
30977                                 zval_copy_ctor(ret);
30978                                 *EG(return_value_ptr_ptr) = ret;
30979                         } else {
30980                                 zval *ret;
30981 
30982                                 ALLOC_ZVAL(ret);
30983                                 INIT_PZVAL_COPY(ret, retval_ptr);
30984                                 *EG(return_value_ptr_ptr) = ret;
30985                         }
30986                         break;
30987                 }
30988 
30989                 retval_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
30990 
30991                 if (IS_CV == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
30992                         zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
30993                 }
30994 
30995                 if (IS_CV == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
30996                         if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
30997                             EX_T(opline->op1.var).var.fcall_returned_reference) {
30998                         } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
30999                                 zend_error(E_NOTICE, "Only variable references should be returned by reference");
31000                                 if (EG(return_value_ptr_ptr)) {
31001                                         zval *ret;
31002 
31003                                         ALLOC_ZVAL(ret);
31004                                         INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
31005                                         zval_copy_ctor(ret);
31006                                         *EG(return_value_ptr_ptr) = ret;
31007                                 }
31008                                 break;
31009                         }
31010                 }
31011 
31012                 if (EG(return_value_ptr_ptr)) {
31013                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
31014                         Z_ADDREF_PP(retval_ptr_ptr);
31015 
31016                         *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
31017                 }
31018         } while (0);
31019 
31020         return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31021 }
31022 
31023 static int ZEND_FASTCALL  ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31024 {
31025         USE_OPLINE
31026         zval *value;
31027         zval *exception;
31028 
31029 
31030         SAVE_OPLINE();
31031         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31032 
31033         if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
31034                 if (UNEXPECTED(EG(exception) != NULL)) {
31035                         HANDLE_EXCEPTION();
31036                 }
31037                 zend_error_noreturn(E_ERROR, "Can only throw objects");
31038         }
31039 
31040         zend_exception_save(TSRMLS_C);
31041         /* Not sure if a complete copy is what we want here */
31042         ALLOC_ZVAL(exception);
31043         INIT_PZVAL_COPY(exception, value);
31044         if (!0) {
31045                 zval_copy_ctor(exception);
31046         }
31047 
31048         zend_throw_exception_object(exception TSRMLS_CC);
31049         zend_exception_restore(TSRMLS_C);
31050 
31051         HANDLE_EXCEPTION();
31052 }
31053 
31054 static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
31055 {
31056         USE_OPLINE
31057         zval *varptr;
31058 
31059         varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31060 
31061         if (varptr == &EG(uninitialized_zval)) {
31062                 if (IS_CV == IS_VAR) {
31063                         Z_DELREF_P(varptr);
31064                 }
31065                 ALLOC_INIT_ZVAL(varptr);
31066         } else if (PZVAL_IS_REF(varptr)) {
31067                 if (IS_CV == IS_CV ||
31068                     (IS_CV == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
31069                         zval *original_var = varptr;
31070 
31071                         ALLOC_ZVAL(varptr);
31072                         INIT_PZVAL_COPY(varptr, original_var);
31073                         zval_copy_ctor(varptr);
31074 
31075                 } else {
31076                         Z_UNSET_ISREF_P(varptr);
31077                 }
31078         } else if (IS_CV == IS_CV) {
31079                 Z_ADDREF_P(varptr);
31080         }
31081         zend_vm_stack_push(varptr TSRMLS_CC);
31082 
31083         CHECK_EXCEPTION();
31084         ZEND_VM_NEXT_OPCODE();
31085 }
31086 
31087 static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31088 {
31089         USE_OPLINE
31090 
31091         zval *varptr;
31092 
31093         SAVE_OPLINE();
31094         if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
31095                 if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
31096                         return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31097                 }
31098         } else {
31099                 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
31100                         return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31101                 }
31102         }
31103 
31104         varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31105         if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
31106              EX_T(opline->op1.var).var.fcall_returned_reference) &&
31107             varptr != &EG(uninitialized_zval) &&
31108             (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) {
31109                 Z_SET_ISREF_P(varptr);
31110                 if (IS_CV == IS_CV) {
31111                         Z_ADDREF_P(varptr);
31112                 }
31113                 zend_vm_stack_push(varptr TSRMLS_CC);
31114         } else {
31115                 zval *valptr;
31116 
31117                 if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
31118                         !(opline->extended_value & ZEND_ARG_SEND_SILENT) :
31119                         !ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
31120                         zend_error(E_STRICT, "Only variables should be passed by reference");
31121                 }
31122                 ALLOC_ZVAL(valptr);
31123                 INIT_PZVAL_COPY(valptr, varptr);
31124                 if (!0) {
31125                         zval_copy_ctor(valptr);
31126                 }
31127 
31128                 zend_vm_stack_push(valptr TSRMLS_CC);
31129         }
31130         CHECK_EXCEPTION();
31131         ZEND_VM_NEXT_OPCODE();
31132 }
31133 
31134 static int ZEND_FASTCALL  ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31135 {
31136         USE_OPLINE
31137 
31138         zval **varptr_ptr;
31139         zval *varptr;
31140 
31141         SAVE_OPLINE();
31142         varptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
31143 
31144         if (IS_CV == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) {
31145                 zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
31146         }
31147 
31148         if (IS_CV == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) {
31149                 ALLOC_INIT_ZVAL(varptr);
31150                 zend_vm_stack_push(varptr TSRMLS_CC);
31151                 CHECK_EXCEPTION();
31152                 ZEND_VM_NEXT_OPCODE();
31153         }
31154 
31155         if (opline->extended_value == ZEND_DO_FCALL_BY_NAME &&
31156             EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
31157                 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
31158                         return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31159                 }
31160         }
31161 
31162         SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
31163         varptr = *varptr_ptr;
31164         Z_ADDREF_P(varptr);
31165         zend_vm_stack_push(varptr TSRMLS_CC);
31166 
31167         CHECK_EXCEPTION();
31168         ZEND_VM_NEXT_OPCODE();
31169 }
31170 
31171 static int ZEND_FASTCALL  ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31172 {
31173         USE_OPLINE
31174 
31175         if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
31176                 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
31177                         return ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31178                 }
31179         }
31180         SAVE_OPLINE();
31181         return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
31182 }
31183 
31184 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31185 {
31186         USE_OPLINE
31187 
31188         zval *retval = &EX_T(opline->result.var).tmp_var;
31189 
31190         SAVE_OPLINE();
31191         /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
31192         ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC)));
31193 
31194         CHECK_EXCEPTION();
31195         ZEND_VM_NEXT_OPCODE();
31196 }
31197 
31198 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31199 {
31200         USE_OPLINE
31201 
31202         zval *obj;
31203         zend_class_entry *ce;
31204         zend_function *clone;
31205         zend_object_clone_obj_t clone_call;
31206 
31207         SAVE_OPLINE();
31208         obj = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31209 
31210         if (IS_CV == IS_CONST ||
31211             UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT)) {
31212                 if (UNEXPECTED(EG(exception) != NULL)) {
31213                         HANDLE_EXCEPTION();
31214                 }
31215                 zend_error_noreturn(E_ERROR, "__clone method called on non-object");
31216         }
31217 
31218         ce = Z_OBJCE_P(obj);
31219         clone = ce ? ce->clone : NULL;
31220         clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
31221         if (UNEXPECTED(clone_call == NULL)) {
31222                 if (ce) {
31223                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
31224                 } else {
31225                         zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
31226                 }
31227         }
31228 
31229         if (ce && clone) {
31230                 if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
31231                         /* Ensure that if we're calling a private function, we're allowed to do so.
31232                          */
31233                         if (UNEXPECTED(ce != EG(scope))) {
31234                                 zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
31235                         }
31236                 } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
31237                         /* Ensure that if we're calling a protected function, we're allowed to do so.
31238                          */
31239                         if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
31240                                 zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
31241                         }
31242                 }
31243         }
31244 
31245         if (EXPECTED(EG(exception) == NULL)) {
31246                 zval *retval;
31247 
31248                 ALLOC_ZVAL(retval);
31249                 Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
31250                 Z_TYPE_P(retval) = IS_OBJECT;
31251                 Z_SET_REFCOUNT_P(retval, 1);
31252                 Z_SET_ISREF_P(retval);
31253                 if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
31254                         zval_ptr_dtor(&retval);
31255                 } else {
31256                         EX_T(opline->result.var).var.ptr = retval;
31257                 }
31258         }
31259 
31260         CHECK_EXCEPTION();
31261         ZEND_VM_NEXT_OPCODE();
31262 }
31263 
31264 static int ZEND_FASTCALL  ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31265 {
31266         USE_OPLINE
31267 
31268         zval *expr;
31269         zval *result = &EX_T(opline->result.var).tmp_var;
31270 
31271         SAVE_OPLINE();
31272         expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31273 
31274         if (opline->extended_value != IS_STRING) {
31275                 ZVAL_COPY_VALUE(result, expr);
31276                 if (!0) {
31277                         zendi_zval_copy_ctor(*result);
31278                 }
31279         }
31280         switch (opline->extended_value) {
31281                 case IS_NULL:
31282                         convert_to_null(result);
31283                         break;
31284                 case IS_BOOL:
31285                         convert_to_boolean(result);
31286                         break;
31287                 case IS_LONG:
31288                         convert_to_long(result);
31289                         break;
31290                 case IS_DOUBLE:
31291                         convert_to_double(result);
31292                         break;
31293                 case IS_STRING: {
31294                         zval var_copy;
31295                         int use_copy;
31296 
31297                         zend_make_printable_zval(expr, &var_copy, &use_copy);
31298                         if (use_copy) {
31299                                 ZVAL_COPY_VALUE(result, &var_copy);
31300                                 if (0) {
31301 
31302                                 }
31303                         } else {
31304                                 ZVAL_COPY_VALUE(result, expr);
31305                                 if (!0) {
31306                                         zendi_zval_copy_ctor(*result);
31307                                 }
31308                         }
31309                         break;
31310                 }
31311                 case IS_ARRAY:
31312                         convert_to_array(result);
31313                         break;
31314                 case IS_OBJECT:
31315                         convert_to_object(result);
31316                         break;
31317         }
31318 
31319         CHECK_EXCEPTION();
31320         ZEND_VM_NEXT_OPCODE();
31321 }
31322 
31323 static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31324 {
31325         USE_OPLINE
31326         zend_op_array *new_op_array=NULL;
31327 
31328         zval *inc_filename;
31329         zval *tmp_inc_filename = NULL;
31330         zend_bool failure_retval=0;
31331 
31332         SAVE_OPLINE();
31333         inc_filename = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31334 
31335         if (inc_filename->type!=IS_STRING) {
31336                 MAKE_STD_ZVAL(tmp_inc_filename);
31337                 ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
31338                 zval_copy_ctor(tmp_inc_filename);
31339                 convert_to_string(tmp_inc_filename);
31340                 inc_filename = tmp_inc_filename;
31341         }
31342 
31343         if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
31344                 if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
31345                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
31346                 } else {
31347                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
31348                 }
31349         } else {
31350                 switch (opline->extended_value) {
31351                         case ZEND_INCLUDE_ONCE:
31352                         case ZEND_REQUIRE_ONCE: {
31353                                         zend_file_handle file_handle;
31354                                         char *resolved_path;
31355 
31356                                         resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
31357                                         if (resolved_path) {
31358                                                 failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
31359                                         } else {
31360                                                 resolved_path = Z_STRVAL_P(inc_filename);
31361                                         }
31362 
31363                                         if (failure_retval) {
31364                                                 /* do nothing, file already included */
31365                                         } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
31366 
31367                                                 if (!file_handle.opened_path) {
31368                                                         file_handle.opened_path = estrdup(resolved_path);
31369                                                 }
31370 
31371                                                 if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
31372                                                         new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
31373                                                         zend_destroy_file_handle(&file_handle TSRMLS_CC);
31374                                                 } else {
31375                                                         zend_file_handle_dtor(&file_handle TSRMLS_CC);
31376                                                         failure_retval=1;
31377                                                 }
31378                                         } else {
31379                                                 if (opline->extended_value == ZEND_INCLUDE_ONCE) {
31380                                                         zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
31381                                                 } else {
31382                                                         zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
31383                                                 }
31384                                         }
31385                                         if (resolved_path != Z_STRVAL_P(inc_filename)) {
31386                                                 efree(resolved_path);
31387                                         }
31388                                 }
31389                                 break;
31390                         case ZEND_INCLUDE:
31391                         case ZEND_REQUIRE:
31392                                 new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
31393                                 break;
31394                         case ZEND_EVAL: {
31395                                         char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
31396 
31397                                         new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
31398                                         efree(eval_desc);
31399                                 }
31400                                 break;
31401                         EMPTY_SWITCH_DEFAULT_CASE()
31402                 }
31403         }
31404         if (tmp_inc_filename) {
31405                 zval_ptr_dtor(&tmp_inc_filename);
31406         }
31407 
31408         if (UNEXPECTED(EG(exception) != NULL)) {
31409                 HANDLE_EXCEPTION();
31410         } else if (EXPECTED(new_op_array != NULL)) {
31411                 EX(original_return_value) = EG(return_value_ptr_ptr);
31412                 EG(active_op_array) = new_op_array;
31413                 if (RETURN_VALUE_USED(opline)) {
31414                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31415                         EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
31416                 } else {
31417                         EG(return_value_ptr_ptr) = NULL;
31418                 }
31419 
31420                 EX(function_state).function = (zend_function *) new_op_array;
31421                 EX(object) = NULL;
31422 
31423                 if (!EG(active_symbol_table)) {
31424                         zend_rebuild_symbol_table(TSRMLS_C);
31425                 }
31426 
31427                 if (EXPECTED(zend_execute_ex == execute_ex)) {
31428                         ZEND_VM_ENTER();
31429                 } else {
31430                         zend_execute(new_op_array TSRMLS_CC);
31431                 }
31432 
31433                 EX(function_state).function = (zend_function *) EX(op_array);
31434 
31435                 EG(opline_ptr) = &EX(opline);
31436                 EG(active_op_array) = EX(op_array);
31437                 EG(return_value_ptr_ptr) = EX(original_return_value);
31438                 destroy_op_array(new_op_array TSRMLS_CC);
31439                 efree(new_op_array);
31440                 if (UNEXPECTED(EG(exception) != NULL)) {
31441                         zend_throw_exception_internal(NULL TSRMLS_CC);
31442                         HANDLE_EXCEPTION();
31443                 }
31444 
31445         } else if (RETURN_VALUE_USED(opline)) {
31446                 zval *retval;
31447 
31448                 ALLOC_ZVAL(retval);
31449                 ZVAL_BOOL(retval, failure_retval);
31450                 INIT_PZVAL(retval);
31451                 EX_T(opline->result.var).var.ptr = retval;
31452         }
31453         ZEND_VM_NEXT_OPCODE();
31454 }
31455 
31456 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31457 {
31458         USE_OPLINE
31459 
31460         zval *array_ptr, **array_ptr_ptr;
31461         HashTable *fe_ht;
31462         zend_object_iterator *iter = NULL;
31463         zend_class_entry *ce = NULL;
31464         zend_bool is_empty = 0;
31465 
31466         SAVE_OPLINE();
31467 
31468         if ((IS_CV == IS_CV || IS_CV == IS_VAR) &&
31469             (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
31470                 array_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31471                 if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
31472                         MAKE_STD_ZVAL(array_ptr);
31473                         ZVAL_NULL(array_ptr);
31474                 } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
31475                         if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
31476                                 zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
31477                                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
31478                         }
31479 
31480                         ce = Z_OBJCE_PP(array_ptr_ptr);
31481                         if (!ce || ce->get_iterator == NULL) {
31482                                 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
31483                                 Z_ADDREF_PP(array_ptr_ptr);
31484                         }
31485                         array_ptr = *array_ptr_ptr;
31486                 } else {
31487                         if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
31488                                 SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
31489                                 if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
31490                                         Z_SET_ISREF_PP(array_ptr_ptr);
31491                                 }
31492                         }
31493                         array_ptr = *array_ptr_ptr;
31494                         Z_ADDREF_P(array_ptr);
31495                 }
31496         } else {
31497                 array_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31498                 if (0) { /* IS_TMP_VAR */
31499                         zval *tmp;
31500 
31501                         ALLOC_ZVAL(tmp);
31502                         INIT_PZVAL_COPY(tmp, array_ptr);
31503                         array_ptr = tmp;
31504                         if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
31505                                 ce = Z_OBJCE_P(array_ptr);
31506                                 if (ce && ce->get_iterator) {
31507                                         Z_DELREF_P(array_ptr);
31508                                 }
31509                         }
31510                 } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
31511                         ce = Z_OBJCE_P(array_ptr);
31512                         if (!ce || !ce->get_iterator) {
31513                                 if (IS_CV == IS_CV) {
31514                                         Z_ADDREF_P(array_ptr);
31515                                 }
31516                         }
31517                 } else if (IS_CV == IS_CONST ||
31518                            (IS_CV == IS_CV &&
31519                             !Z_ISREF_P(array_ptr) &&
31520                             Z_REFCOUNT_P(array_ptr) > 1) ||
31521                            (IS_CV == IS_VAR &&
31522                             !Z_ISREF_P(array_ptr) &&
31523                             Z_REFCOUNT_P(array_ptr) > 2)) {
31524                         zval *tmp;
31525 
31526                         if (IS_CV == IS_VAR) {
31527                                 Z_DELREF_P(array_ptr);
31528                         }
31529                         ALLOC_ZVAL(tmp);
31530                         INIT_PZVAL_COPY(tmp, array_ptr);
31531                         zval_copy_ctor(tmp);
31532                         array_ptr = tmp;
31533                 } else if (IS_CV == IS_CV) {
31534                         Z_ADDREF_P(array_ptr);
31535                 }
31536         }
31537 
31538         if (ce && ce->get_iterator) {
31539                 iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
31540 
31541                 if (IS_CV == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
31542 
31543                 }
31544                 if (iter && EXPECTED(EG(exception) == NULL)) {
31545                         array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
31546                 } else {
31547                         if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
31548 
31549                         }
31550                         if (!EG(exception)) {
31551                                 zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
31552                         }
31553                         zend_throw_exception_internal(NULL TSRMLS_CC);
31554                         HANDLE_EXCEPTION();
31555                 }
31556         }
31557 
31558         EX_T(opline->result.var).fe.ptr = array_ptr;
31559 
31560         if (iter) {
31561                 iter->index = 0;
31562                 if (iter->funcs->rewind) {
31563                         iter->funcs->rewind(iter TSRMLS_CC);
31564                         if (UNEXPECTED(EG(exception) != NULL)) {
31565                                 zval_ptr_dtor(&array_ptr);
31566                                 if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
31567 
31568                                 }
31569                                 HANDLE_EXCEPTION();
31570                         }
31571                 }
31572                 is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
31573                 if (UNEXPECTED(EG(exception) != NULL)) {
31574                         zval_ptr_dtor(&array_ptr);
31575                         if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
31576 
31577                         }
31578                         HANDLE_EXCEPTION();
31579                 }
31580                 iter->index = -1; /* will be set to 0 before using next handler */
31581         } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
31582                 zend_hash_internal_pointer_reset(fe_ht);
31583                 if (ce) {
31584                         zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
31585                         while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
31586                                 char *str_key;
31587                                 uint str_key_len;
31588                                 ulong int_key;
31589                                 zend_uchar key_type;
31590 
31591                                 key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
31592                                 if (key_type != HASH_KEY_NON_EXISTENT &&
31593                                         (key_type == HASH_KEY_IS_LONG ||
31594                                      zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
31595                                         break;
31596                                 }
31597                                 zend_hash_move_forward(fe_ht);
31598                         }
31599                 }
31600                 is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
31601                 zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
31602         } else {
31603                 zend_error(E_WARNING, "Invalid argument supplied for foreach()");
31604                 is_empty = 1;
31605         }
31606 
31607         if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
31608 
31609         }
31610         if (is_empty) {
31611                 ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
31612         } else {
31613                 CHECK_EXCEPTION();
31614                 ZEND_VM_NEXT_OPCODE();
31615         }
31616 }
31617 
31618 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31619 {
31620 #if 0 || (IS_CV != IS_UNUSED)
31621         USE_OPLINE
31622 
31623         SAVE_OPLINE();
31624         if (IS_CV != IS_UNUSED) {
31625 
31626                 zval *ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31627 
31628                 if (Z_TYPE_P(ptr) == IS_LONG) {
31629                         EG(exit_status) = Z_LVAL_P(ptr);
31630                 } else {
31631                         zend_print_variable(ptr);
31632                 }
31633 
31634         }
31635 #endif
31636         zend_bailout();
31637         ZEND_VM_NEXT_OPCODE(); /* Never reached */
31638 }
31639 
31640 static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31641 {
31642         USE_OPLINE
31643 
31644         zval *value;
31645 
31646         SAVE_OPLINE();
31647         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31648 
31649         if (i_zend_is_true(value)) {
31650                 ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
31651                 if (!0) {
31652                         zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
31653                 }
31654 
31655 #if DEBUG_ZEND>=2
31656                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
31657 #endif
31658                 ZEND_VM_JMP(opline->op2.jmp_addr);
31659         }
31660 
31661         CHECK_EXCEPTION();
31662         ZEND_VM_NEXT_OPCODE();
31663 }
31664 
31665 static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31666 {
31667         USE_OPLINE
31668 
31669         zval *value, *ret;
31670 
31671         SAVE_OPLINE();
31672         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31673 
31674         if (i_zend_is_true(value)) {
31675                 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
31676                         Z_ADDREF_P(value);
31677                         EX_T(opline->result.var).var.ptr = value;
31678                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31679                 } else {
31680                         ALLOC_ZVAL(ret);
31681                         INIT_PZVAL_COPY(ret, value);
31682                         EX_T(opline->result.var).var.ptr = ret;
31683                         EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31684                         if (!0) {
31685                                 zval_copy_ctor(EX_T(opline->result.var).var.ptr);
31686                         }
31687                 }
31688 
31689 #if DEBUG_ZEND>=2
31690                 printf("Conditional jmp to %d\n", opline->op2.opline_num);
31691 #endif
31692                 ZEND_VM_JMP(opline->op2.jmp_addr);
31693         }
31694 
31695         CHECK_EXCEPTION();
31696         ZEND_VM_NEXT_OPCODE();
31697 }
31698 
31699 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31700 {
31701         USE_OPLINE
31702 
31703         zval *value;
31704 
31705         SAVE_OPLINE();
31706         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31707 
31708         ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
31709         if (!0) {
31710                 zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
31711         }
31712 
31713         CHECK_EXCEPTION();
31714         ZEND_VM_NEXT_OPCODE();
31715 }
31716 
31717 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31718 {
31719         USE_OPLINE
31720 
31721         zval *value, *ret;
31722 
31723         SAVE_OPLINE();
31724         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31725 
31726         if (IS_CV == IS_VAR || IS_CV == IS_CV) {
31727                 Z_ADDREF_P(value);
31728                 EX_T(opline->result.var).var.ptr = value;
31729                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31730         } else {
31731                 ALLOC_ZVAL(ret);
31732                 INIT_PZVAL_COPY(ret, value);
31733                 EX_T(opline->result.var).var.ptr = ret;
31734                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
31735                 if (!0) {
31736                         zval_copy_ctor(EX_T(opline->result.var).var.ptr);
31737                 }
31738         }
31739 
31740         CHECK_EXCEPTION();
31741         ZEND_VM_NEXT_OPCODE();
31742 }
31743 
31744 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31745 {
31746         USE_OPLINE
31747 
31748         zval *expr;
31749         zend_bool result;
31750 
31751         SAVE_OPLINE();
31752         expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
31753 
31754         if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
31755                 result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
31756         } else {
31757                 result = 0;
31758         }
31759         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
31760 
31761         CHECK_EXCEPTION();
31762         ZEND_VM_NEXT_OPCODE();
31763 }
31764 
31765 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31766 {
31767         USE_OPLINE
31768 
31769 
31770         SAVE_OPLINE();
31771         fast_add_function(&EX_T(opline->result.var).tmp_var,
31772                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31773                 opline->op2.zv TSRMLS_CC);
31774 
31775 
31776         CHECK_EXCEPTION();
31777         ZEND_VM_NEXT_OPCODE();
31778 }
31779 
31780 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31781 {
31782         USE_OPLINE
31783 
31784 
31785         SAVE_OPLINE();
31786         fast_sub_function(&EX_T(opline->result.var).tmp_var,
31787                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31788                 opline->op2.zv TSRMLS_CC);
31789 
31790 
31791         CHECK_EXCEPTION();
31792         ZEND_VM_NEXT_OPCODE();
31793 }
31794 
31795 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31796 {
31797         USE_OPLINE
31798 
31799 
31800         SAVE_OPLINE();
31801         fast_mul_function(&EX_T(opline->result.var).tmp_var,
31802                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31803                 opline->op2.zv TSRMLS_CC);
31804 
31805 
31806         CHECK_EXCEPTION();
31807         ZEND_VM_NEXT_OPCODE();
31808 }
31809 
31810 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31811 {
31812         USE_OPLINE
31813 
31814 
31815         SAVE_OPLINE();
31816         fast_div_function(&EX_T(opline->result.var).tmp_var,
31817                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31818                 opline->op2.zv TSRMLS_CC);
31819 
31820 
31821         CHECK_EXCEPTION();
31822         ZEND_VM_NEXT_OPCODE();
31823 }
31824 
31825 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31826 {
31827         USE_OPLINE
31828 
31829 
31830         SAVE_OPLINE();
31831         fast_mod_function(&EX_T(opline->result.var).tmp_var,
31832                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31833                 opline->op2.zv TSRMLS_CC);
31834 
31835 
31836         CHECK_EXCEPTION();
31837         ZEND_VM_NEXT_OPCODE();
31838 }
31839 
31840 static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31841 {
31842         USE_OPLINE
31843 
31844 
31845         SAVE_OPLINE();
31846         shift_left_function(&EX_T(opline->result.var).tmp_var,
31847                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31848                 opline->op2.zv TSRMLS_CC);
31849 
31850 
31851         CHECK_EXCEPTION();
31852         ZEND_VM_NEXT_OPCODE();
31853 }
31854 
31855 static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31856 {
31857         USE_OPLINE
31858 
31859 
31860         SAVE_OPLINE();
31861         shift_right_function(&EX_T(opline->result.var).tmp_var,
31862                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31863                 opline->op2.zv TSRMLS_CC);
31864 
31865 
31866         CHECK_EXCEPTION();
31867         ZEND_VM_NEXT_OPCODE();
31868 }
31869 
31870 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31871 {
31872         USE_OPLINE
31873 
31874 
31875         SAVE_OPLINE();
31876         concat_function(&EX_T(opline->result.var).tmp_var,
31877                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31878                 opline->op2.zv TSRMLS_CC);
31879 
31880 
31881         CHECK_EXCEPTION();
31882         ZEND_VM_NEXT_OPCODE();
31883 }
31884 
31885 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31886 {
31887         USE_OPLINE
31888 
31889 
31890         SAVE_OPLINE();
31891         is_identical_function(&EX_T(opline->result.var).tmp_var,
31892                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31893                 opline->op2.zv TSRMLS_CC);
31894 
31895 
31896         CHECK_EXCEPTION();
31897         ZEND_VM_NEXT_OPCODE();
31898 }
31899 
31900 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31901 {
31902         USE_OPLINE
31903 
31904         zval *result = &EX_T(opline->result.var).tmp_var;
31905 
31906         SAVE_OPLINE();
31907         is_identical_function(result,
31908                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31909                 opline->op2.zv TSRMLS_CC);
31910         Z_LVAL_P(result) = !Z_LVAL_P(result);
31911 
31912 
31913         CHECK_EXCEPTION();
31914         ZEND_VM_NEXT_OPCODE();
31915 }
31916 
31917 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31918 {
31919         USE_OPLINE
31920 
31921         zval *result = &EX_T(opline->result.var).tmp_var;
31922 
31923         SAVE_OPLINE();
31924         ZVAL_BOOL(result, fast_equal_function(result,
31925                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31926                 opline->op2.zv TSRMLS_CC));
31927 
31928 
31929         CHECK_EXCEPTION();
31930         ZEND_VM_NEXT_OPCODE();
31931 }
31932 
31933 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31934 {
31935         USE_OPLINE
31936 
31937         zval *result = &EX_T(opline->result.var).tmp_var;
31938 
31939         SAVE_OPLINE();
31940         ZVAL_BOOL(result, fast_not_equal_function(result,
31941                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31942                 opline->op2.zv TSRMLS_CC));
31943 
31944 
31945         CHECK_EXCEPTION();
31946         ZEND_VM_NEXT_OPCODE();
31947 }
31948 
31949 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31950 {
31951         USE_OPLINE
31952 
31953         zval *result = &EX_T(opline->result.var).tmp_var;
31954 
31955         SAVE_OPLINE();
31956         ZVAL_BOOL(result, fast_is_smaller_function(result,
31957                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31958                 opline->op2.zv TSRMLS_CC));
31959 
31960 
31961         CHECK_EXCEPTION();
31962         ZEND_VM_NEXT_OPCODE();
31963 }
31964 
31965 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31966 {
31967         USE_OPLINE
31968 
31969         zval *result = &EX_T(opline->result.var).tmp_var;
31970 
31971         SAVE_OPLINE();
31972         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
31973                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31974                 opline->op2.zv TSRMLS_CC));
31975 
31976 
31977         CHECK_EXCEPTION();
31978         ZEND_VM_NEXT_OPCODE();
31979 }
31980 
31981 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31982 {
31983         USE_OPLINE
31984 
31985 
31986         SAVE_OPLINE();
31987         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
31988                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
31989                 opline->op2.zv TSRMLS_CC);
31990 
31991 
31992         CHECK_EXCEPTION();
31993         ZEND_VM_NEXT_OPCODE();
31994 }
31995 
31996 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31997 {
31998         USE_OPLINE
31999 
32000 
32001         SAVE_OPLINE();
32002         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
32003                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32004                 opline->op2.zv TSRMLS_CC);
32005 
32006 
32007         CHECK_EXCEPTION();
32008         ZEND_VM_NEXT_OPCODE();
32009 }
32010 
32011 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32012 {
32013         USE_OPLINE
32014 
32015 
32016         SAVE_OPLINE();
32017         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
32018                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32019                 opline->op2.zv TSRMLS_CC);
32020 
32021 
32022         CHECK_EXCEPTION();
32023         ZEND_VM_NEXT_OPCODE();
32024 }
32025 
32026 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32027 {
32028         USE_OPLINE
32029 
32030 
32031         SAVE_OPLINE();
32032         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
32033                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
32034                 opline->op2.zv TSRMLS_CC);
32035 
32036 
32037         CHECK_EXCEPTION();
32038         ZEND_VM_NEXT_OPCODE();
32039 }
32040 
32041 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
32042 {
32043         USE_OPLINE
32044         zend_free_op free_op_data1;
32045         zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32046         zval *object;
32047         zval *property = opline->op2.zv;
32048         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
32049         int have_get_ptr = 0;
32050 
32051         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
32052                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
32053         }
32054 
32055         make_real_object(object_ptr TSRMLS_CC);
32056         object = *object_ptr;
32057 
32058         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32059                 zend_error(E_WARNING, "Attempt to assign property of non-object");
32060 
32061                 FREE_OP(free_op_data1);
32062 
32063                 if (RETURN_VALUE_USED(opline)) {
32064                         PZVAL_LOCK(&EG(uninitialized_zval));
32065                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32066                 }
32067         } else {
32068                 /* here we are sure we are dealing with an object */
32069                 if (0) {
32070                         MAKE_REAL_ZVAL_PTR(property);
32071                 }
32072 
32073                 /* here property is a string */
32074                 if (opline->extended_value == ZEND_ASSIGN_OBJ
32075                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
32076                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32077                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
32078                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
32079 
32080                                 have_get_ptr = 1;
32081                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
32082                                 if (RETURN_VALUE_USED(opline)) {
32083                                         PZVAL_LOCK(*zptr);
32084                                         EX_T(opline->result.var).var.ptr = *zptr;
32085                                 }
32086                         }
32087                 }
32088 
32089                 if (!have_get_ptr) {
32090                         zval *z = NULL;
32091 
32092                         Z_ADDREF_P(object);
32093                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
32094                                 if (Z_OBJ_HT_P(object)->read_property) {
32095                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32096                                 }
32097                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
32098                                 if (Z_OBJ_HT_P(object)->read_dimension) {
32099                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
32100                                 }
32101                         }
32102                         if (z) {
32103                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
32104                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
32105 
32106                                         if (Z_REFCOUNT_P(z) == 0) {
32107                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
32108                                                 zval_dtor(z);
32109                                                 FREE_ZVAL(z);
32110                                         }
32111                                         z = value;
32112                                 }
32113                                 Z_ADDREF_P(z);
32114                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
32115                                 binary_op(z, z, value TSRMLS_CC);
32116                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
32117                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32118                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
32119                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
32120                                 }
32121                                 if (RETURN_VALUE_USED(opline)) {
32122                                         PZVAL_LOCK(z);
32123                                         EX_T(opline->result.var).var.ptr = z;
32124                                 }
32125                                 zval_ptr_dtor(&z);
32126                         } else {
32127                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
32128                                 if (RETURN_VALUE_USED(opline)) {
32129                                         PZVAL_LOCK(&EG(uninitialized_zval));
32130                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32131                                 }
32132                         }
32133                         zval_ptr_dtor(&object);
32134                 }
32135 
32136                 if (0) {
32137                         zval_ptr_dtor(&property);
32138                 } else {
32139 
32140                 }
32141                 FREE_OP(free_op_data1);
32142         }
32143 
32144         /* assign_obj has two opcodes! */
32145         CHECK_EXCEPTION();
32146         ZEND_VM_INC_OPCODE();
32147         ZEND_VM_NEXT_OPCODE();
32148 }
32149 
32150 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
32151 {
32152         USE_OPLINE
32153         zend_free_op free_op_data2, free_op_data1;
32154         zval **var_ptr;
32155         zval *value;
32156 
32157         SAVE_OPLINE();
32158         switch (opline->extended_value) {
32159                 case ZEND_ASSIGN_OBJ:
32160                         return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32161                         break;
32162                 case ZEND_ASSIGN_DIM: {
32163                                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32164 
32165                                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32166                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32167                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
32168                                         if (IS_CV == IS_VAR && !0) {
32169                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
32170                                         }
32171                                         return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32172                                 } else {
32173                                         zval *dim = opline->op2.zv;
32174 
32175                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
32176                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
32177                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
32178                                 }
32179                         }
32180                         break;
32181                 default:
32182                         value = opline->op2.zv;
32183                         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32184                         /* do nothing */
32185                         break;
32186         }
32187 
32188         if (UNEXPECTED(var_ptr == NULL)) {
32189                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
32190         }
32191 
32192         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
32193                 if (RETURN_VALUE_USED(opline)) {
32194                         PZVAL_LOCK(&EG(uninitialized_zval));
32195                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32196                 }
32197 
32198 
32199                 CHECK_EXCEPTION();
32200                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
32201                         ZEND_VM_INC_OPCODE();
32202                 }
32203                 ZEND_VM_NEXT_OPCODE();
32204         }
32205 
32206         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
32207 
32208         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
32209            && Z_OBJ_HANDLER_PP(var_ptr, get)
32210            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
32211                 /* proxy object */
32212                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
32213                 Z_ADDREF_P(objval);
32214                 binary_op(objval, objval, value TSRMLS_CC);
32215                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
32216                 zval_ptr_dtor(&objval);
32217         } else {
32218                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
32219         }
32220 
32221         if (RETURN_VALUE_USED(opline)) {
32222                 PZVAL_LOCK(*var_ptr);
32223                 EX_T(opline->result.var).var.ptr = *var_ptr;
32224         }
32225 
32226         if (opline->extended_value == ZEND_ASSIGN_DIM) {
32227                 FREE_OP(free_op_data1);
32228                 FREE_OP_VAR_PTR(free_op_data2);
32229 
32230                 CHECK_EXCEPTION();
32231                 ZEND_VM_INC_OPCODE();
32232         } else {
32233 
32234                 CHECK_EXCEPTION();
32235         }
32236         ZEND_VM_NEXT_OPCODE();
32237 }
32238 
32239 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32240 {
32241         return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32242 }
32243 
32244 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32245 {
32246         return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32247 }
32248 
32249 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32250 {
32251         return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32252 }
32253 
32254 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32255 {
32256         return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32257 }
32258 
32259 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32260 {
32261         return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32262 }
32263 
32264 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32265 {
32266         return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32267 }
32268 
32269 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32270 {
32271         return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32272 }
32273 
32274 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32275 {
32276         return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32277 }
32278 
32279 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32280 {
32281         return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32282 }
32283 
32284 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32285 {
32286         return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32287 }
32288 
32289 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32290 {
32291         return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32292 }
32293 
32294 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
32295 {
32296         USE_OPLINE
32297 
32298         zval **object_ptr;
32299         zval *object;
32300         zval *property;
32301         zval **retval;
32302         int have_get_ptr = 0;
32303 
32304         SAVE_OPLINE();
32305         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32306         property = opline->op2.zv;
32307         retval = &EX_T(opline->result.var).var.ptr;
32308 
32309         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
32310                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
32311         }
32312 
32313         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
32314         object = *object_ptr;
32315 
32316         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32317                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
32318 
32319                 if (RETURN_VALUE_USED(opline)) {
32320                         PZVAL_LOCK(&EG(uninitialized_zval));
32321                         *retval = &EG(uninitialized_zval);
32322                 }
32323 
32324                 CHECK_EXCEPTION();
32325                 ZEND_VM_NEXT_OPCODE();
32326         }
32327 
32328         /* here we are sure we are dealing with an object */
32329 
32330         if (0) {
32331                 MAKE_REAL_ZVAL_PTR(property);
32332         }
32333 
32334         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
32335                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32336                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
32337                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
32338 
32339                         have_get_ptr = 1;
32340                         incdec_op(*zptr);
32341                         if (RETURN_VALUE_USED(opline)) {
32342                                 *retval = *zptr;
32343                                 PZVAL_LOCK(*retval);
32344                         }
32345                 }
32346         }
32347 
32348         if (!have_get_ptr) {
32349                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
32350                         zval *z;
32351 
32352                         Z_ADDREF_P(object);
32353                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32354 
32355                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
32356                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
32357 
32358                                 if (Z_REFCOUNT_P(z) == 0) {
32359                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
32360                                         zval_dtor(z);
32361                                         FREE_ZVAL(z);
32362                                 }
32363                                 z = value;
32364                         }
32365                         Z_ADDREF_P(z);
32366                         SEPARATE_ZVAL_IF_NOT_REF(&z);
32367                         incdec_op(z);
32368                         *retval = z;
32369                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32370                         zval_ptr_dtor(&object);
32371                         SELECTIVE_PZVAL_LOCK(*retval, opline);
32372                         zval_ptr_dtor(&z);
32373                 } else {
32374                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
32375                         if (RETURN_VALUE_USED(opline)) {
32376                                 PZVAL_LOCK(&EG(uninitialized_zval));
32377                                 *retval = &EG(uninitialized_zval);
32378                         }
32379                 }
32380         }
32381 
32382         if (0) {
32383                 zval_ptr_dtor(&property);
32384         } else {
32385 
32386         }
32387 
32388         CHECK_EXCEPTION();
32389         ZEND_VM_NEXT_OPCODE();
32390 }
32391 
32392 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32393 {
32394         return zend_pre_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32395 }
32396 
32397 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32398 {
32399         return zend_pre_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32400 }
32401 
32402 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
32403 {
32404         USE_OPLINE
32405 
32406         zval **object_ptr;
32407         zval *object;
32408         zval *property;
32409         zval *retval;
32410         int have_get_ptr = 0;
32411 
32412         SAVE_OPLINE();
32413         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32414         property = opline->op2.zv;
32415         retval = &EX_T(opline->result.var).tmp_var;
32416 
32417         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
32418                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
32419         }
32420 
32421         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
32422         object = *object_ptr;
32423 
32424         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32425                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
32426 
32427                 ZVAL_NULL(retval);
32428 
32429                 CHECK_EXCEPTION();
32430                 ZEND_VM_NEXT_OPCODE();
32431         }
32432 
32433         /* here we are sure we are dealing with an object */
32434 
32435         if (0) {
32436                 MAKE_REAL_ZVAL_PTR(property);
32437         }
32438 
32439         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
32440                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32441                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
32442                         have_get_ptr = 1;
32443                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
32444 
32445                         ZVAL_COPY_VALUE(retval, *zptr);
32446                         zendi_zval_copy_ctor(*retval);
32447 
32448                         incdec_op(*zptr);
32449 
32450                 }
32451         }
32452 
32453         if (!have_get_ptr) {
32454                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
32455                         zval *z, *z_copy;
32456 
32457                         Z_ADDREF_P(object);
32458                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32459                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
32460                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
32461 
32462                                 if (Z_REFCOUNT_P(z) == 0) {
32463                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
32464                                         zval_dtor(z);
32465                                         FREE_ZVAL(z);
32466                                 }
32467                                 z = value;
32468                         }
32469                         ZVAL_COPY_VALUE(retval, z);
32470                         zendi_zval_copy_ctor(*retval);
32471                         ALLOC_ZVAL(z_copy);
32472                         INIT_PZVAL_COPY(z_copy, z);
32473                         zendi_zval_copy_ctor(*z_copy);
32474                         incdec_op(z_copy);
32475                         Z_ADDREF_P(z);
32476                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32477                         zval_ptr_dtor(&object);
32478                         zval_ptr_dtor(&z_copy);
32479                         zval_ptr_dtor(&z);
32480                 } else {
32481                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
32482                         ZVAL_NULL(retval);
32483                 }
32484         }
32485 
32486         if (0) {
32487                 zval_ptr_dtor(&property);
32488         } else {
32489 
32490         }
32491 
32492         CHECK_EXCEPTION();
32493         ZEND_VM_NEXT_OPCODE();
32494 }
32495 
32496 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32497 {
32498         return zend_post_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32499 }
32500 
32501 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32502 {
32503         return zend_post_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32504 }
32505 
32506 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
32507 {
32508         USE_OPLINE
32509         zend_free_op free_op1;
32510         zval *varname;
32511         zval **retval;
32512         zval tmp_varname;
32513         HashTable *target_symbol_table;
32514         ulong hash_value;
32515 
32516         SAVE_OPLINE();
32517         varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
32518 
32519         if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
32520                 ZVAL_COPY_VALUE(&tmp_varname, varname);
32521                 zval_copy_ctor(&tmp_varname);
32522                 Z_SET_REFCOUNT(tmp_varname, 1);
32523                 Z_UNSET_ISREF(tmp_varname);
32524                 convert_to_string(&tmp_varname);
32525                 varname = &tmp_varname;
32526         }
32527 
32528         if (IS_CONST != IS_UNUSED) {
32529                 zend_class_entry *ce;
32530 
32531                 if (IS_CONST == IS_CONST) {
32532                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
32533                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
32534                         } else {
32535                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
32536                                 if (UNEXPECTED(ce == NULL)) {
32537                                         if (IS_CV != IS_CONST && varname == &tmp_varname) {
32538                                                 zval_dtor(&tmp_varname);
32539                                         }
32540 
32541                                         CHECK_EXCEPTION();
32542                                         ZEND_VM_NEXT_OPCODE();
32543                                 }
32544                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
32545                         }
32546                 } else {
32547                         ce = EX_T(opline->op2.var).class_entry;
32548                 }
32549                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
32550 
32551         } else {
32552                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
32553 /*
32554                 if (!target_symbol_table) {
32555                         CHECK_EXCEPTION();
32556                         ZEND_VM_NEXT_OPCODE();
32557                 }
32558 */
32559                 if (IS_CV == IS_CONST) {
32560                         hash_value = Z_HASH_P(varname);
32561                 } else {
32562                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
32563                 }
32564 
32565                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
32566                         switch (type) {
32567                                 case BP_VAR_R:
32568                                 case BP_VAR_UNSET:
32569                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
32570                                         /* break missing intentionally */
32571                                 case BP_VAR_IS:
32572                                         retval = &EG(uninitialized_zval_ptr);
32573                                         break;
32574                                 case BP_VAR_RW:
32575                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
32576                                         /* break missing intentionally */
32577                                 case BP_VAR_W:
32578                                         Z_ADDREF_P(&EG(uninitialized_zval));
32579                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
32580                                         break;
32581                                 EMPTY_SWITCH_DEFAULT_CASE()
32582                         }
32583                 }
32584                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
32585                         case ZEND_FETCH_GLOBAL:
32586                                 if (IS_CV != IS_TMP_VAR) {
32587 
32588                                 }
32589                                 break;
32590                         case ZEND_FETCH_LOCAL:
32591 
32592                                 break;
32593                         case ZEND_FETCH_STATIC:
32594                                 zval_update_constant(retval, 1 TSRMLS_CC);
32595                                 break;
32596                         case ZEND_FETCH_GLOBAL_LOCK:
32597                                 if (IS_CV == IS_VAR && !free_op1.var) {
32598                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
32599                                 }
32600                                 break;
32601                 }
32602         }
32603 
32604 
32605         if (IS_CV != IS_CONST && varname == &tmp_varname) {
32606                 zval_dtor(&tmp_varname);
32607         }
32608         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
32609                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
32610         }
32611         PZVAL_LOCK(*retval);
32612         switch (type) {
32613                 case BP_VAR_R:
32614                 case BP_VAR_IS:
32615                         EX_T(opline->result.var).var.ptr = *retval;
32616                         break;
32617                 case BP_VAR_UNSET: {
32618                         zend_free_op free_res;
32619 
32620                         PZVAL_UNLOCK(*retval, &free_res);
32621                         if (retval != &EG(uninitialized_zval_ptr)) {
32622                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
32623                         }
32624                         PZVAL_LOCK(*retval);
32625                         FREE_OP_VAR_PTR(free_res);
32626                 }
32627                 /* break missing intentionally */
32628                 default:
32629                         EX_T(opline->result.var).var.ptr_ptr = retval;
32630                         break;
32631         }
32632         CHECK_EXCEPTION();
32633         ZEND_VM_NEXT_OPCODE();
32634 }
32635 
32636 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32637 {
32638         return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32639 }
32640 
32641 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32642 {
32643         return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32644 }
32645 
32646 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32647 {
32648         return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32649 }
32650 
32651 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32652 {
32653         USE_OPLINE
32654 
32655         return zend_fetch_var_address_helper_SPEC_CV_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32656 }
32657 
32658 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32659 {
32660         return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32661 }
32662 
32663 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32664 {
32665         return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32666 }
32667 
32668 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32669 {
32670         USE_OPLINE
32671 
32672         zval *container;
32673 
32674         SAVE_OPLINE();
32675         container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
32676         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
32677 
32678         if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
32679 
32680         }
32681         CHECK_EXCEPTION();
32682         ZEND_VM_NEXT_OPCODE();
32683 }
32684 
32685 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32686 {
32687         USE_OPLINE
32688         zend_free_op free_op1;
32689         zval **container;
32690 
32691         SAVE_OPLINE();
32692         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
32693 
32694         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32695                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32696         }
32697         zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
32698 
32699         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32700                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32701         }
32702 
32703         /* We are going to assign the result by reference */
32704         if (UNEXPECTED(opline->extended_value != 0)) {
32705                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
32706 
32707                 if (retval_ptr) {
32708                         Z_DELREF_PP(retval_ptr);
32709                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
32710                         Z_ADDREF_PP(retval_ptr);
32711                 }
32712         }
32713 
32714         CHECK_EXCEPTION();
32715         ZEND_VM_NEXT_OPCODE();
32716 }
32717 
32718 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32719 {
32720         USE_OPLINE
32721         zend_free_op free_op1;
32722         zval **container;
32723 
32724         SAVE_OPLINE();
32725         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32726 
32727         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32728                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32729         }
32730         zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC);
32731 
32732         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32733                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32734         }
32735 
32736         CHECK_EXCEPTION();
32737         ZEND_VM_NEXT_OPCODE();
32738 }
32739 
32740 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32741 {
32742         USE_OPLINE
32743 
32744         zval *container;
32745 
32746         SAVE_OPLINE();
32747         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
32748         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC);
32749 
32750 
32751         CHECK_EXCEPTION();
32752         ZEND_VM_NEXT_OPCODE();
32753 }
32754 
32755 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32756 {
32757         USE_OPLINE
32758         zend_free_op free_op1;
32759 
32760         SAVE_OPLINE();
32761 
32762         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
32763                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
32764                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32765                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32766                 }
32767                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
32768                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32769                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32770                 }
32771 
32772 
32773         } else {
32774                 zval *container;
32775 
32776                 if (IS_CONST == IS_UNUSED) {
32777                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
32778                 }
32779                 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
32780                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
32781 
32782 
32783         }
32784         CHECK_EXCEPTION();
32785         ZEND_VM_NEXT_OPCODE();
32786 }
32787 
32788 static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32789 {
32790         USE_OPLINE
32791         zend_free_op free_op1;
32792         zval **container;
32793 
32794         SAVE_OPLINE();
32795         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
32796 
32797         if (IS_CV == IS_CV) {
32798                 if (container != &EG(uninitialized_zval_ptr)) {
32799                         SEPARATE_ZVAL_IF_NOT_REF(container);
32800                 }
32801         }
32802         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32803                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
32804         }
32805         zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC);
32806 
32807         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32808                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32809         }
32810 
32811         if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
32812                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
32813                 ZEND_VM_NEXT_OPCODE();
32814         } else {
32815                 zend_free_op free_res;
32816                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
32817 
32818                 PZVAL_UNLOCK(*retval_ptr, &free_res);
32819                 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
32820                         SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
32821                 }
32822                 PZVAL_LOCK(*retval_ptr);
32823                 FREE_OP_VAR_PTR(free_res);
32824                 CHECK_EXCEPTION();
32825                 ZEND_VM_NEXT_OPCODE();
32826         }
32827 }
32828 
32829 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS)
32830 {
32831         USE_OPLINE
32832 
32833         zval *container;
32834 
32835         zval *offset;
32836 
32837         SAVE_OPLINE();
32838         container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
32839         offset  = opline->op2.zv;
32840 
32841         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
32842             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
32843                 zend_error(E_NOTICE, "Trying to get property of non-object");
32844                 PZVAL_LOCK(&EG(uninitialized_zval));
32845                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32846 
32847         } else {
32848                 zval *retval;
32849 
32850                 if (0) {
32851                         MAKE_REAL_ZVAL_PTR(offset);
32852                 }
32853 
32854                 /* here we are sure we are dealing with an object */
32855                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32856 
32857                 PZVAL_LOCK(retval);
32858                 EX_T(opline->result.var).var.ptr = retval;
32859 
32860                 if (0) {
32861                         zval_ptr_dtor(&offset);
32862                 } else {
32863 
32864                 }
32865         }
32866 
32867         CHECK_EXCEPTION();
32868         ZEND_VM_NEXT_OPCODE();
32869 }
32870 
32871 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32872 {
32873         return zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
32874 }
32875 
32876 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32877 {
32878         USE_OPLINE
32879         zend_free_op free_op1;
32880         zval *property;
32881         zval **container;
32882 
32883         SAVE_OPLINE();
32884         property = opline->op2.zv;
32885 
32886         if (0) {
32887                 MAKE_REAL_ZVAL_PTR(property);
32888         }
32889         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
32890         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32891                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
32892         }
32893 
32894         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
32895         if (0) {
32896                 zval_ptr_dtor(&property);
32897         } else {
32898 
32899         }
32900         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32901                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32902         }
32903 
32904         /* We are going to assign the result by reference */
32905         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
32906                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
32907 
32908                 Z_DELREF_PP(retval_ptr);
32909                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
32910                 Z_ADDREF_PP(retval_ptr);
32911                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
32912                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
32913         }
32914 
32915         CHECK_EXCEPTION();
32916         ZEND_VM_NEXT_OPCODE();
32917 }
32918 
32919 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32920 {
32921         USE_OPLINE
32922         zend_free_op free_op1;
32923         zval *property;
32924         zval **container;
32925 
32926         SAVE_OPLINE();
32927         property = opline->op2.zv;
32928         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
32929 
32930         if (0) {
32931                 MAKE_REAL_ZVAL_PTR(property);
32932         }
32933         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
32934                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
32935         }
32936         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
32937         if (0) {
32938                 zval_ptr_dtor(&property);
32939         } else {
32940 
32941         }
32942         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
32943                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
32944         }
32945 
32946         CHECK_EXCEPTION();
32947         ZEND_VM_NEXT_OPCODE();
32948 }
32949 
32950 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32951 {
32952         USE_OPLINE
32953 
32954         zval *container;
32955 
32956         zval *offset;
32957 
32958         SAVE_OPLINE();
32959         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
32960         offset  = opline->op2.zv;
32961 
32962         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
32963             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
32964                 PZVAL_LOCK(&EG(uninitialized_zval));
32965                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
32966 
32967         } else {
32968                 zval *retval;
32969 
32970                 if (0) {
32971                         MAKE_REAL_ZVAL_PTR(offset);
32972                 }
32973 
32974                 /* here we are sure we are dealing with an object */
32975                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
32976 
32977                 PZVAL_LOCK(retval);
32978                 EX_T(opline->result.var).var.ptr = retval;
32979 
32980                 if (0) {
32981                         zval_ptr_dtor(&offset);
32982                 } else {
32983 
32984                 }
32985         }
32986 
32987         CHECK_EXCEPTION();
32988         ZEND_VM_NEXT_OPCODE();
32989 }
32990 
32991 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32992 {
32993         USE_OPLINE
32994 
32995         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
32996                 /* Behave like FETCH_OBJ_W */
32997                 zend_free_op free_op1;
32998                 zval *property;
32999                 zval **container;
33000 
33001                 SAVE_OPLINE();
33002                 property = opline->op2.zv;
33003                 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33004 
33005                 if (0) {
33006                         MAKE_REAL_ZVAL_PTR(property);
33007                 }
33008                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
33009                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
33010                 }
33011                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
33012                 if (0) {
33013                         zval_ptr_dtor(&property);
33014                 } else {
33015 
33016                 }
33017                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
33018                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
33019                 }
33020 
33021                 CHECK_EXCEPTION();
33022                 ZEND_VM_NEXT_OPCODE();
33023         } else {
33024                 return zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
33025         }
33026 }
33027 
33028 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33029 {
33030         USE_OPLINE
33031         zend_free_op free_op1, free_res;
33032         zval **container;
33033         zval *property;
33034 
33035         SAVE_OPLINE();
33036         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
33037         property = opline->op2.zv;
33038 
33039         if (IS_CV == IS_CV) {
33040                 if (container != &EG(uninitialized_zval_ptr)) {
33041                         SEPARATE_ZVAL_IF_NOT_REF(container);
33042                 }
33043         }
33044         if (0) {
33045                 MAKE_REAL_ZVAL_PTR(property);
33046         }
33047         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
33048                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
33049         }
33050         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
33051         if (0) {
33052                 zval_ptr_dtor(&property);
33053         } else {
33054 
33055         }
33056         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
33057                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
33058         }
33059 
33060         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
33061         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
33062                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
33063         }
33064         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
33065         FREE_OP_VAR_PTR(free_res);
33066         CHECK_EXCEPTION();
33067         ZEND_VM_NEXT_OPCODE();
33068 }
33069 
33070 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33071 {
33072         USE_OPLINE
33073 
33074         zval **object_ptr;
33075         zval *property_name;
33076 
33077         SAVE_OPLINE();
33078         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33079         property_name = opline->op2.zv;
33080 
33081         if (0) {
33082                 MAKE_REAL_ZVAL_PTR(property_name);
33083         }
33084         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
33085                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
33086         }
33087         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33088         if (0) {
33089                 zval_ptr_dtor(&property_name);
33090         } else {
33091 
33092         }
33093 
33094         /* assign_obj has two opcodes! */
33095         CHECK_EXCEPTION();
33096         ZEND_VM_INC_OPCODE();
33097         ZEND_VM_NEXT_OPCODE();
33098 }
33099 
33100 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33101 {
33102         USE_OPLINE
33103 
33104         zval **object_ptr;
33105 
33106         SAVE_OPLINE();
33107         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33108 
33109         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
33110                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
33111         }
33112         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
33113 
33114                 zval *property_name = opline->op2.zv;
33115 
33116                 if (0) {
33117                         MAKE_REAL_ZVAL_PTR(property_name);
33118                 }
33119                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33120                 if (0) {
33121                         zval_ptr_dtor(&property_name);
33122                 } else {
33123 
33124                 }
33125         } else {
33126                 zend_free_op free_op_data1, free_op_data2;
33127                 zval *value;
33128                 zval *dim = opline->op2.zv;
33129                 zval **variable_ptr_ptr;
33130 
33131                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC);
33132 
33133                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
33134                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
33135                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
33136                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
33137                                 if (RETURN_VALUE_USED(opline)) {
33138                                         zval *retval;
33139 
33140                                         ALLOC_ZVAL(retval);
33141                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
33142                                         INIT_PZVAL(retval);
33143                                         EX_T(opline->result.var).var.ptr = retval;
33144                                 }
33145                         } else if (RETURN_VALUE_USED(opline)) {
33146                                 PZVAL_LOCK(&EG(uninitialized_zval));
33147                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33148                         }
33149                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
33150                         if (IS_TMP_FREE(free_op_data1)) {
33151                                 zval_dtor(value);
33152                         }
33153                         if (RETURN_VALUE_USED(opline)) {
33154                                 PZVAL_LOCK(&EG(uninitialized_zval));
33155                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33156                         }
33157                 } else {
33158                         if ((opline+1)->op1_type == IS_TMP_VAR) {
33159                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33160                         } else if ((opline+1)->op1_type == IS_CONST) {
33161                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33162                         } else {
33163                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33164                         }
33165                         if (RETURN_VALUE_USED(opline)) {
33166                                 PZVAL_LOCK(value);
33167                                 EX_T(opline->result.var).var.ptr = value;
33168                         }
33169                 }
33170                 FREE_OP_VAR_PTR(free_op_data2);
33171                 FREE_OP_IF_VAR(free_op_data1);
33172         }
33173 
33174         /* assign_dim has two opcodes! */
33175         CHECK_EXCEPTION();
33176         ZEND_VM_INC_OPCODE();
33177         ZEND_VM_NEXT_OPCODE();
33178 }
33179 
33180 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33181 {
33182         USE_OPLINE
33183 
33184         zval *value;
33185         zval **variable_ptr_ptr;
33186 
33187         SAVE_OPLINE();
33188         value = opline->op2.zv;
33189         variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33190 
33191         if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
33192                 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
33193                         if (RETURN_VALUE_USED(opline)) {
33194                                 zval *retval;
33195 
33196                                 ALLOC_ZVAL(retval);
33197                                 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
33198                                 INIT_PZVAL(retval);
33199                                 EX_T(opline->result.var).var.ptr = retval;
33200                         }
33201                 } else if (RETURN_VALUE_USED(opline)) {
33202                         PZVAL_LOCK(&EG(uninitialized_zval));
33203                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33204                 }
33205         } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
33206                 if (0) {
33207                         zval_dtor(value);
33208                 }
33209                 if (RETURN_VALUE_USED(opline)) {
33210                         PZVAL_LOCK(&EG(uninitialized_zval));
33211                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
33212                 }
33213         } else {
33214                 if (IS_CONST == IS_TMP_VAR) {
33215                         value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33216                 } else if (IS_CONST == IS_CONST) {
33217                         value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33218                 } else {
33219                         value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
33220                 }
33221                 if (RETURN_VALUE_USED(opline)) {
33222                         PZVAL_LOCK(value);
33223                         EX_T(opline->result.var).var.ptr = value;
33224                 }
33225         }
33226 
33227         if (IS_CV == IS_VAR && 0) {
33228                 zval_ptr_dtor_nogc(&value);
33229         }
33230 
33231         /* zend_assign_to_variable() always takes care of op2, never free it! */
33232 
33233         CHECK_EXCEPTION();
33234         ZEND_VM_NEXT_OPCODE();
33235 }
33236 
33237 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33238 {
33239         USE_OPLINE
33240         zval *function_name;
33241         char *function_name_strval;
33242         int function_name_strlen;
33243 
33244         call_slot *call = EX(call_slots) + opline->result.num;
33245 
33246         SAVE_OPLINE();
33247 
33248         function_name = opline->op2.zv;
33249 
33250         if (IS_CONST != IS_CONST &&
33251             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
33252                 if (UNEXPECTED(EG(exception) != NULL)) {
33253                         HANDLE_EXCEPTION();
33254                 }
33255                 zend_error_noreturn(E_ERROR, "Method name must be a string");
33256         }
33257 
33258         function_name_strval = Z_STRVAL_P(function_name);
33259         function_name_strlen = Z_STRLEN_P(function_name);
33260 
33261         call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33262 
33263         if (EXPECTED(call->object != NULL) &&
33264             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
33265                 call->called_scope = Z_OBJCE_P(call->object);
33266 
33267                 if (IS_CONST != IS_CONST ||
33268                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
33269                     zval *object = call->object;
33270 
33271                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
33272                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
33273                         }
33274 
33275                         /* First, locate the function. */
33276                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
33277                         if (UNEXPECTED(call->fbc == NULL)) {
33278                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
33279                         }
33280                         if (IS_CONST == IS_CONST &&
33281                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
33282                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
33283                             EXPECTED(call->object == object)) {
33284                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
33285                         }
33286                 }
33287         } else {
33288                 if (UNEXPECTED(EG(exception) != NULL)) {
33289 
33290                         HANDLE_EXCEPTION();
33291                 }
33292                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
33293         }
33294 
33295         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
33296                 call->object = NULL;
33297         } else {
33298                 if (!PZVAL_IS_REF(call->object)) {
33299                         Z_ADDREF_P(call->object); /* For $this pointer */
33300                 } else {
33301                         zval *this_ptr;
33302                         ALLOC_ZVAL(this_ptr);
33303                         INIT_PZVAL_COPY(this_ptr, call->object);
33304                         zval_copy_ctor(this_ptr);
33305                         call->object = this_ptr;
33306                 }
33307         }
33308 
33309         call->num_additional_args = 0;
33310         call->is_ctor_call = 0;
33311         EX(call) = call;
33312 
33313 
33314         CHECK_EXCEPTION();
33315         ZEND_VM_NEXT_OPCODE();
33316 }
33317 
33318 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33319 {
33320         USE_OPLINE
33321 
33322 
33323         SAVE_OPLINE();
33324         is_equal_function(&EX_T(opline->result.var).tmp_var,
33325                                  _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
33326                                  opline->op2.zv TSRMLS_CC);
33327 
33328         CHECK_EXCEPTION();
33329         ZEND_VM_NEXT_OPCODE();
33330 }
33331 
33332 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33333 {
33334         USE_OPLINE
33335 
33336         zval *expr_ptr;
33337 
33338         SAVE_OPLINE();
33339         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
33340                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33341 
33342                 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
33343                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
33344                 }
33345                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
33346                 expr_ptr = *expr_ptr_ptr;
33347                 Z_ADDREF_P(expr_ptr);
33348         } else {
33349                 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33350                 if (0) { /* temporary variable */
33351                         zval *new_expr;
33352 
33353                         ALLOC_ZVAL(new_expr);
33354                         INIT_PZVAL_COPY(new_expr, expr_ptr);
33355                         expr_ptr = new_expr;
33356                 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
33357                         zval *new_expr;
33358 
33359                         ALLOC_ZVAL(new_expr);
33360                         INIT_PZVAL_COPY(new_expr, expr_ptr);
33361                         expr_ptr = new_expr;
33362                         zendi_zval_copy_ctor(*expr_ptr);
33363 
33364                 } else if (IS_CV == IS_CV) {
33365                         Z_ADDREF_P(expr_ptr);
33366                 }
33367         }
33368 
33369         if (IS_CONST != IS_UNUSED) {
33370 
33371                 zval *offset = opline->op2.zv;
33372                 ulong hval;
33373 
33374                 switch (Z_TYPE_P(offset)) {
33375                         case IS_DOUBLE:
33376                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
33377                                 goto num_index;
33378                         case IS_LONG:
33379                         case IS_BOOL:
33380                                 hval = Z_LVAL_P(offset);
33381 num_index:
33382                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
33383                                 break;
33384                         case IS_STRING:
33385                                 if (IS_CONST == IS_CONST) {
33386                                         hval = Z_HASH_P(offset);
33387                                 } else {
33388                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
33389                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
33390                                 }
33391                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
33392                                 break;
33393                         case IS_NULL:
33394                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
33395                                 break;
33396                         default:
33397                                 zend_error(E_WARNING, "Illegal offset type");
33398                                 zval_ptr_dtor(&expr_ptr);
33399                                 /* do nothing */
33400                                 break;
33401                 }
33402 
33403         } else {
33404                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
33405         }
33406         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
33407 
33408         }
33409         CHECK_EXCEPTION();
33410         ZEND_VM_NEXT_OPCODE();
33411 }
33412 
33413 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33414 {
33415         USE_OPLINE
33416 
33417         array_init(&EX_T(opline->result.var).tmp_var);
33418         if (IS_CV == IS_UNUSED) {
33419                 ZEND_VM_NEXT_OPCODE();
33420 #if 0 || IS_CV != IS_UNUSED
33421         } else {
33422                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
33423 #endif
33424         }
33425 }
33426 
33427 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33428 {
33429         USE_OPLINE
33430         zval tmp, *varname;
33431         HashTable *target_symbol_table;
33432 
33433 
33434         SAVE_OPLINE();
33435         if (IS_CV == IS_CV &&
33436             IS_CONST == IS_UNUSED &&
33437             (opline->extended_value & ZEND_QUICK_SET)) {
33438                 if (EG(active_symbol_table)) {
33439                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
33440 
33441                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
33442                         EX_CV(opline->op1.var) = NULL;
33443                 } else if (EX_CV(opline->op1.var)) {
33444                         zval_ptr_dtor(EX_CV(opline->op1.var));
33445                         EX_CV(opline->op1.var) = NULL;
33446                 }
33447                 CHECK_EXCEPTION();
33448                 ZEND_VM_NEXT_OPCODE();
33449         }
33450 
33451         varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33452 
33453         if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
33454                 ZVAL_COPY_VALUE(&tmp, varname);
33455                 zval_copy_ctor(&tmp);
33456                 convert_to_string(&tmp);
33457                 varname = &tmp;
33458         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
33459                 Z_ADDREF_P(varname);
33460         }
33461 
33462         if (IS_CONST != IS_UNUSED) {
33463                 zend_class_entry *ce;
33464 
33465                 if (IS_CONST == IS_CONST) {
33466                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
33467                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
33468                         } else {
33469                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
33470                                 if (UNEXPECTED(EG(exception) != NULL)) {
33471                                         if (IS_CV != IS_CONST && varname == &tmp) {
33472                                                 zval_dtor(&tmp);
33473                                         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
33474                                                 zval_ptr_dtor(&varname);
33475                                         }
33476 
33477                                         HANDLE_EXCEPTION();
33478                                 }
33479                                 if (UNEXPECTED(ce == NULL)) {
33480                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
33481                                 }
33482                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
33483                         }
33484                 } else {
33485                         ce = EX_T(opline->op2.var).class_entry;
33486                 }
33487                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
33488         } else {
33489                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
33490 
33491                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
33492                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
33493         }
33494 
33495         if (IS_CV != IS_CONST && varname == &tmp) {
33496                 zval_dtor(&tmp);
33497         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
33498                 zval_ptr_dtor(&varname);
33499         }
33500 
33501         CHECK_EXCEPTION();
33502         ZEND_VM_NEXT_OPCODE();
33503 }
33504 
33505 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33506 {
33507         USE_OPLINE
33508 
33509         zval **container;
33510         zval *offset;
33511         ulong hval;
33512 
33513         SAVE_OPLINE();
33514         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
33515         if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
33516                 SEPARATE_ZVAL_IF_NOT_REF(container);
33517         }
33518         offset = opline->op2.zv;
33519 
33520         if (IS_CV != IS_VAR || container) {
33521                 switch (Z_TYPE_PP(container)) {
33522                         case IS_ARRAY: {
33523                                 HashTable *ht = Z_ARRVAL_PP(container);
33524 
33525                                 switch (Z_TYPE_P(offset)) {
33526                                         case IS_DOUBLE:
33527                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
33528                                                 zend_hash_index_del(ht, hval);
33529                                                 break;
33530                                         case IS_RESOURCE:
33531                                         case IS_BOOL:
33532                                         case IS_LONG:
33533                                                 hval = Z_LVAL_P(offset);
33534                                                 zend_hash_index_del(ht, hval);
33535                                                 break;
33536                                         case IS_STRING:
33537                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
33538                                                         Z_ADDREF_P(offset);
33539                                                 }
33540                                                 if (IS_CONST == IS_CONST) {
33541                                                         hval = Z_HASH_P(offset);
33542                                                 } else {
33543                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
33544                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
33545                                                 }
33546                                                 if (ht == &EG(symbol_table)) {
33547                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
33548                                                 } else {
33549                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
33550                                                 }
33551                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
33552                                                         zval_ptr_dtor(&offset);
33553                                                 }
33554                                                 break;
33555 num_index_dim:
33556                                                 zend_hash_index_del(ht, hval);
33557                                                 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
33558                                                         zval_ptr_dtor(&offset);
33559                                                 }
33560                                                 break;
33561                                         case IS_NULL:
33562                                                 zend_hash_del(ht, "", sizeof(""));
33563                                                 break;
33564                                         default:
33565                                                 zend_error(E_WARNING, "Illegal offset type in unset");
33566                                                 break;
33567                                 }
33568 
33569                                 break;
33570                         }
33571                         case IS_OBJECT:
33572                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
33573                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
33574                                 }
33575                                 if (0) {
33576                                         MAKE_REAL_ZVAL_PTR(offset);
33577                                 }
33578                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
33579                                 if (0) {
33580                                         zval_ptr_dtor(&offset);
33581                                 } else {
33582 
33583                                 }
33584                                 break;
33585                         case IS_STRING:
33586                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
33587                                 ZEND_VM_CONTINUE(); /* bailed out before */
33588                         default:
33589 
33590                                 break;
33591                 }
33592         } else {
33593 
33594         }
33595 
33596         CHECK_EXCEPTION();
33597         ZEND_VM_NEXT_OPCODE();
33598 }
33599 
33600 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33601 {
33602         USE_OPLINE
33603 
33604         zval **container;
33605         zval *offset;
33606 
33607         SAVE_OPLINE();
33608         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
33609         offset = opline->op2.zv;
33610 
33611         if (IS_CV != IS_VAR || container) {
33612                 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
33613                         SEPARATE_ZVAL_IF_NOT_REF(container);
33614                 }
33615                 if (Z_TYPE_PP(container) == IS_OBJECT) {
33616                         if (0) {
33617                                 MAKE_REAL_ZVAL_PTR(offset);
33618                         }
33619                         if (Z_OBJ_HT_P(*container)->unset_property) {
33620                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33621                         } else {
33622                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
33623                         }
33624                         if (0) {
33625                                 zval_ptr_dtor(&offset);
33626                         } else {
33627 
33628                         }
33629                 } else {
33630 
33631                 }
33632         } else {
33633 
33634         }
33635 
33636         CHECK_EXCEPTION();
33637         ZEND_VM_NEXT_OPCODE();
33638 }
33639 
33640 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33641 {
33642         USE_OPLINE
33643         zval **value;
33644         zend_bool isset = 1;
33645 
33646         SAVE_OPLINE();
33647         if (IS_CV == IS_CV &&
33648             IS_CONST == IS_UNUSED &&
33649             (opline->extended_value & ZEND_QUICK_SET)) {
33650                 if (EX_CV(opline->op1.var)) {
33651                         value = EX_CV(opline->op1.var);
33652                 } else if (EG(active_symbol_table)) {
33653                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
33654 
33655                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
33656                                 isset = 0;
33657                         }
33658                 } else {
33659                         isset = 0;
33660                 }
33661         } else {
33662                 HashTable *target_symbol_table;
33663 
33664                 zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
33665 
33666                 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
33667                         ZVAL_COPY_VALUE(&tmp, varname);
33668                         zval_copy_ctor(&tmp);
33669                         convert_to_string(&tmp);
33670                         varname = &tmp;
33671                 }
33672 
33673                 if (IS_CONST != IS_UNUSED) {
33674                         zend_class_entry *ce;
33675 
33676                         if (IS_CONST == IS_CONST) {
33677                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
33678                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
33679                                 } else {
33680                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
33681                                         if (UNEXPECTED(ce == NULL)) {
33682                                                 CHECK_EXCEPTION();
33683                                                 ZEND_VM_NEXT_OPCODE();
33684                                         }
33685                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
33686                                 }
33687                         } else {
33688                                 ce = EX_T(opline->op2.var).class_entry;
33689                         }
33690                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
33691                         if (!value) {
33692                                 isset = 0;
33693                         }
33694                 } else {
33695                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
33696                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
33697                                 isset = 0;
33698                         }
33699                 }
33700 
33701                 if (IS_CV != IS_CONST && varname == &tmp) {
33702                         zval_dtor(&tmp);
33703                 }
33704 
33705         }
33706 
33707         if (opline->extended_value & ZEND_ISSET) {
33708                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
33709                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
33710                 } else {
33711                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
33712                 }
33713         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
33714                 if (!isset || !i_zend_is_true(*value)) {
33715                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
33716                 } else {
33717                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
33718                 }
33719         }
33720 
33721         CHECK_EXCEPTION();
33722         ZEND_VM_NEXT_OPCODE();
33723 }
33724 
33725 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
33726 {
33727         USE_OPLINE
33728 
33729         zval *container;
33730         zval **value = NULL;
33731         int result = 0;
33732         ulong hval;
33733         zval *offset;
33734 
33735         SAVE_OPLINE();
33736         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
33737         offset = opline->op2.zv;
33738 
33739         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
33740                 HashTable *ht;
33741                 int isset = 0;
33742 
33743                 ht = Z_ARRVAL_P(container);
33744 
33745                 switch (Z_TYPE_P(offset)) {
33746                         case IS_DOUBLE:
33747                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
33748                                 goto num_index_prop;
33749                         case IS_RESOURCE:
33750                         case IS_BOOL:
33751                         case IS_LONG:
33752                                 hval = Z_LVAL_P(offset);
33753 num_index_prop:
33754                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
33755                                         isset = 1;
33756                                 }
33757                                 break;
33758                         case IS_STRING:
33759                                 if (IS_CONST == IS_CONST) {
33760                                         hval = Z_HASH_P(offset);
33761                                 } else {
33762                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
33763                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
33764                                 }
33765                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
33766                                         isset = 1;
33767                                 }
33768                                 break;
33769                         case IS_NULL:
33770                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
33771                                         isset = 1;
33772                                 }
33773                                 break;
33774                         default:
33775                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
33776                                 break;
33777                 }
33778 
33779                 if (opline->extended_value & ZEND_ISSET) {
33780                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
33781                                 result = 0;
33782                         } else {
33783                                 result = isset;
33784                         }
33785                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
33786                         if (!isset || !i_zend_is_true(*value)) {
33787                                 result = 0;
33788                         } else {
33789                                 result = 1;
33790                         }
33791                 }
33792 
33793         } else if (Z_TYPE_P(container) == IS_OBJECT) {
33794                 if (0) {
33795                         MAKE_REAL_ZVAL_PTR(offset);
33796                 }
33797                 if (prop_dim) {
33798                         if (Z_OBJ_HT_P(container)->has_property) {
33799                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
33800                         } else {
33801                                 zend_error(E_NOTICE, "Trying to check property of non-object");
33802                                 result = 0;
33803                         }
33804                 } else {
33805                         if (Z_OBJ_HT_P(container)->has_dimension) {
33806                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
33807                         } else {
33808                                 zend_error(E_NOTICE, "Trying to check element of non-array");
33809                                 result = 0;
33810                         }
33811                 }
33812                 if (0) {
33813                         zval_ptr_dtor(&offset);
33814                 } else {
33815 
33816                 }
33817         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
33818                 zval tmp;
33819 
33820                 if (Z_TYPE_P(offset) != IS_LONG) {
33821                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
33822                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
33823                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
33824                                 ZVAL_COPY_VALUE(&tmp, offset);
33825                                 zval_copy_ctor(&tmp);
33826                                 convert_to_long(&tmp);
33827                                 offset = &tmp;
33828                         } else {
33829                                 /* can not be converted to proper offset, return "not set" */
33830                                 result = 0;
33831                         }
33832                 }
33833                 if (Z_TYPE_P(offset) == IS_LONG) {
33834                         if (opline->extended_value & ZEND_ISSET) {
33835                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
33836                                         result = 1;
33837                                 }
33838                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
33839                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
33840                                         result = 1;
33841                                 }
33842                         }
33843                 }
33844 
33845         } else {
33846 
33847         }
33848 
33849         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
33850         if (opline->extended_value & ZEND_ISSET) {
33851                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
33852         } else {
33853                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
33854         }
33855 
33856         CHECK_EXCEPTION();
33857         ZEND_VM_NEXT_OPCODE();
33858 }
33859 
33860 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33861 {
33862         return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
33863 }
33864 
33865 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33866 {
33867         return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
33868 }
33869 
33870 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33871 {
33872         USE_OPLINE
33873 
33874         /* The generator object is stored in return_value_ptr_ptr */
33875         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
33876 
33877         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
33878                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
33879         }
33880 
33881         /* Destroy the previously yielded value */
33882         if (generator->value) {
33883                 zval_ptr_dtor(&generator->value);
33884         }
33885 
33886         /* Destroy the previously yielded key */
33887         if (generator->key) {
33888                 zval_ptr_dtor(&generator->key);
33889         }
33890 
33891         /* Set the new yielded value */
33892         if (IS_CV != IS_UNUSED) {
33893 
33894 
33895                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
33896                         /* Constants and temporary variables aren't yieldable by reference,
33897                          * but we still allow them with a notice. */
33898                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
33899                                 zval *value, *copy;
33900 
33901                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33902 
33903                                 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33904                                 ALLOC_ZVAL(copy);
33905                                 INIT_PZVAL_COPY(copy, value);
33906 
33907                                 /* Temporary variables don't need ctor copying */
33908                                 if (!0) {
33909                                         zval_copy_ctor(copy);
33910                                 }
33911 
33912                                 generator->value = copy;
33913                         } else {
33914                                 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
33915 
33916                                 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
33917                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
33918                                 }
33919 
33920                                 /* If a function call result is yielded and the function did
33921                                  * not return by reference we throw a notice. */
33922                                 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
33923                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
33924                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
33925                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
33926                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33927 
33928                                         Z_ADDREF_PP(value_ptr);
33929                                         generator->value = *value_ptr;
33930                                 } else {
33931                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
33932                                         Z_ADDREF_PP(value_ptr);
33933                                         generator->value = *value_ptr;
33934                                 }
33935 
33936                         }
33937                 } else {
33938                         zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
33939 
33940                         /* Consts, temporary variables and references need copying */
33941                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
33942                                 || PZVAL_IS_REF(value)
33943                         ) {
33944                                 zval *copy;
33945 
33946                                 ALLOC_ZVAL(copy);
33947                                 INIT_PZVAL_COPY(copy, value);
33948 
33949                                 /* Temporary variables don't need ctor copying */
33950                                 if (!0) {
33951                                         zval_copy_ctor(copy);
33952                                 }
33953 
33954                                 generator->value = copy;
33955 
33956                         } else {
33957                                 if (IS_CV == IS_CV) {
33958                                         Z_ADDREF_P(value);
33959                                 }
33960                                 generator->value = value;
33961                         }
33962                 }
33963         } else {
33964                 /* If no value was specified yield null */
33965                 Z_ADDREF(EG(uninitialized_zval));
33966                 generator->value = &EG(uninitialized_zval);
33967         }
33968 
33969         /* Set the new yielded key */
33970         if (IS_CONST != IS_UNUSED) {
33971 
33972                 zval *key = opline->op2.zv;
33973 
33974                 /* Consts, temporary variables and references need copying */
33975                 if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
33976                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
33977                 ) {
33978                         zval *copy;
33979 
33980                         ALLOC_ZVAL(copy);
33981                         INIT_PZVAL_COPY(copy, key);
33982 
33983                         /* Temporary variables don't need ctor copying */
33984                         if (!0) {
33985                                 zval_copy_ctor(copy);
33986                         }
33987 
33988                         generator->key = copy;
33989                 } else {
33990                         Z_ADDREF_P(key);
33991                         generator->key = key;
33992                 }
33993 
33994                 if (Z_TYPE_P(generator->key) == IS_LONG
33995                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
33996                 ) {
33997                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
33998                 }
33999 
34000         } else {
34001                 /* If no key was specified we use auto-increment keys */
34002                 generator->largest_used_integer_key++;
34003 
34004                 ALLOC_INIT_ZVAL(generator->key);
34005                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
34006         }
34007 
34008         if (RETURN_VALUE_USED(opline)) {
34009                 /* If the return value of yield is used set the send
34010                  * target and initialize it to NULL */
34011                 generator->send_target = &EX_T(opline->result.var).var.ptr;
34012                 Z_ADDREF(EG(uninitialized_zval));
34013                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34014         } else {
34015                 generator->send_target = NULL;
34016         }
34017 
34018         /* We increment to the next op, so we are at the correct position when the
34019          * generator is resumed. */
34020         ZEND_VM_INC_OPCODE();
34021 
34022         /* The GOTO VM uses a local opline variable. We need to set the opline
34023          * variable in execute_data so we don't resume at an old position. */
34024         SAVE_OPLINE();
34025 
34026         ZEND_VM_RETURN();
34027 }
34028 
34029 static int ZEND_FASTCALL  ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34030 {
34031         USE_OPLINE
34032 
34033 
34034         SAVE_OPLINE();
34035         pow_function(&EX_T(opline->result.var).tmp_var,
34036                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34037                 opline->op2.zv TSRMLS_CC);
34038 
34039 
34040         CHECK_EXCEPTION();
34041         ZEND_VM_NEXT_OPCODE();
34042 }
34043 
34044 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34045 {
34046         return zend_binary_assign_op_helper_SPEC_CV_CONST(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34047 }
34048 
34049 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34050 {
34051         USE_OPLINE
34052         zend_free_op free_op2;
34053 
34054         SAVE_OPLINE();
34055         fast_add_function(&EX_T(opline->result.var).tmp_var,
34056                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34057                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34058 
34059         zval_dtor(free_op2.var);
34060         CHECK_EXCEPTION();
34061         ZEND_VM_NEXT_OPCODE();
34062 }
34063 
34064 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34065 {
34066         USE_OPLINE
34067         zend_free_op free_op2;
34068 
34069         SAVE_OPLINE();
34070         fast_sub_function(&EX_T(opline->result.var).tmp_var,
34071                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34072                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34073 
34074         zval_dtor(free_op2.var);
34075         CHECK_EXCEPTION();
34076         ZEND_VM_NEXT_OPCODE();
34077 }
34078 
34079 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34080 {
34081         USE_OPLINE
34082         zend_free_op free_op2;
34083 
34084         SAVE_OPLINE();
34085         fast_mul_function(&EX_T(opline->result.var).tmp_var,
34086                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34087                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34088 
34089         zval_dtor(free_op2.var);
34090         CHECK_EXCEPTION();
34091         ZEND_VM_NEXT_OPCODE();
34092 }
34093 
34094 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34095 {
34096         USE_OPLINE
34097         zend_free_op free_op2;
34098 
34099         SAVE_OPLINE();
34100         fast_div_function(&EX_T(opline->result.var).tmp_var,
34101                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34102                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34103 
34104         zval_dtor(free_op2.var);
34105         CHECK_EXCEPTION();
34106         ZEND_VM_NEXT_OPCODE();
34107 }
34108 
34109 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34110 {
34111         USE_OPLINE
34112         zend_free_op free_op2;
34113 
34114         SAVE_OPLINE();
34115         fast_mod_function(&EX_T(opline->result.var).tmp_var,
34116                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34117                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34118 
34119         zval_dtor(free_op2.var);
34120         CHECK_EXCEPTION();
34121         ZEND_VM_NEXT_OPCODE();
34122 }
34123 
34124 static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34125 {
34126         USE_OPLINE
34127         zend_free_op free_op2;
34128 
34129         SAVE_OPLINE();
34130         shift_left_function(&EX_T(opline->result.var).tmp_var,
34131                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34132                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34133 
34134         zval_dtor(free_op2.var);
34135         CHECK_EXCEPTION();
34136         ZEND_VM_NEXT_OPCODE();
34137 }
34138 
34139 static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34140 {
34141         USE_OPLINE
34142         zend_free_op free_op2;
34143 
34144         SAVE_OPLINE();
34145         shift_right_function(&EX_T(opline->result.var).tmp_var,
34146                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34147                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34148 
34149         zval_dtor(free_op2.var);
34150         CHECK_EXCEPTION();
34151         ZEND_VM_NEXT_OPCODE();
34152 }
34153 
34154 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34155 {
34156         USE_OPLINE
34157         zend_free_op free_op2;
34158 
34159         SAVE_OPLINE();
34160         concat_function(&EX_T(opline->result.var).tmp_var,
34161                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34162                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34163 
34164         zval_dtor(free_op2.var);
34165         CHECK_EXCEPTION();
34166         ZEND_VM_NEXT_OPCODE();
34167 }
34168 
34169 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34170 {
34171         USE_OPLINE
34172         zend_free_op free_op2;
34173 
34174         SAVE_OPLINE();
34175         is_identical_function(&EX_T(opline->result.var).tmp_var,
34176                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34177                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34178 
34179         zval_dtor(free_op2.var);
34180         CHECK_EXCEPTION();
34181         ZEND_VM_NEXT_OPCODE();
34182 }
34183 
34184 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34185 {
34186         USE_OPLINE
34187         zend_free_op free_op2;
34188         zval *result = &EX_T(opline->result.var).tmp_var;
34189 
34190         SAVE_OPLINE();
34191         is_identical_function(result,
34192                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34193                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34194         Z_LVAL_P(result) = !Z_LVAL_P(result);
34195 
34196         zval_dtor(free_op2.var);
34197         CHECK_EXCEPTION();
34198         ZEND_VM_NEXT_OPCODE();
34199 }
34200 
34201 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34202 {
34203         USE_OPLINE
34204         zend_free_op free_op2;
34205         zval *result = &EX_T(opline->result.var).tmp_var;
34206 
34207         SAVE_OPLINE();
34208         ZVAL_BOOL(result, fast_equal_function(result,
34209                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34210                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
34211 
34212         zval_dtor(free_op2.var);
34213         CHECK_EXCEPTION();
34214         ZEND_VM_NEXT_OPCODE();
34215 }
34216 
34217 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34218 {
34219         USE_OPLINE
34220         zend_free_op free_op2;
34221         zval *result = &EX_T(opline->result.var).tmp_var;
34222 
34223         SAVE_OPLINE();
34224         ZVAL_BOOL(result, fast_not_equal_function(result,
34225                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34226                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
34227 
34228         zval_dtor(free_op2.var);
34229         CHECK_EXCEPTION();
34230         ZEND_VM_NEXT_OPCODE();
34231 }
34232 
34233 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34234 {
34235         USE_OPLINE
34236         zend_free_op free_op2;
34237         zval *result = &EX_T(opline->result.var).tmp_var;
34238 
34239         SAVE_OPLINE();
34240         ZVAL_BOOL(result, fast_is_smaller_function(result,
34241                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34242                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
34243 
34244         zval_dtor(free_op2.var);
34245         CHECK_EXCEPTION();
34246         ZEND_VM_NEXT_OPCODE();
34247 }
34248 
34249 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34250 {
34251         USE_OPLINE
34252         zend_free_op free_op2;
34253         zval *result = &EX_T(opline->result.var).tmp_var;
34254 
34255         SAVE_OPLINE();
34256         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
34257                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34258                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
34259 
34260         zval_dtor(free_op2.var);
34261         CHECK_EXCEPTION();
34262         ZEND_VM_NEXT_OPCODE();
34263 }
34264 
34265 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34266 {
34267         USE_OPLINE
34268         zend_free_op free_op2;
34269 
34270         SAVE_OPLINE();
34271         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
34272                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34273                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34274 
34275         zval_dtor(free_op2.var);
34276         CHECK_EXCEPTION();
34277         ZEND_VM_NEXT_OPCODE();
34278 }
34279 
34280 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34281 {
34282         USE_OPLINE
34283         zend_free_op free_op2;
34284 
34285         SAVE_OPLINE();
34286         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
34287                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34288                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34289 
34290         zval_dtor(free_op2.var);
34291         CHECK_EXCEPTION();
34292         ZEND_VM_NEXT_OPCODE();
34293 }
34294 
34295 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34296 {
34297         USE_OPLINE
34298         zend_free_op free_op2;
34299 
34300         SAVE_OPLINE();
34301         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
34302                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34303                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34304 
34305         zval_dtor(free_op2.var);
34306         CHECK_EXCEPTION();
34307         ZEND_VM_NEXT_OPCODE();
34308 }
34309 
34310 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34311 {
34312         USE_OPLINE
34313         zend_free_op free_op2;
34314 
34315         SAVE_OPLINE();
34316         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
34317                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
34318                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
34319 
34320         zval_dtor(free_op2.var);
34321         CHECK_EXCEPTION();
34322         ZEND_VM_NEXT_OPCODE();
34323 }
34324 
34325 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
34326 {
34327         USE_OPLINE
34328         zend_free_op free_op2, free_op_data1;
34329         zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34330         zval *object;
34331         zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34332         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
34333         int have_get_ptr = 0;
34334 
34335         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
34336                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
34337         }
34338 
34339         make_real_object(object_ptr TSRMLS_CC);
34340         object = *object_ptr;
34341 
34342         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34343                 zend_error(E_WARNING, "Attempt to assign property of non-object");
34344                 zval_dtor(free_op2.var);
34345                 FREE_OP(free_op_data1);
34346 
34347                 if (RETURN_VALUE_USED(opline)) {
34348                         PZVAL_LOCK(&EG(uninitialized_zval));
34349                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34350                 }
34351         } else {
34352                 /* here we are sure we are dealing with an object */
34353                 if (1) {
34354                         MAKE_REAL_ZVAL_PTR(property);
34355                 }
34356 
34357                 /* here property is a string */
34358                 if (opline->extended_value == ZEND_ASSIGN_OBJ
34359                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
34360                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34361                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
34362                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
34363 
34364                                 have_get_ptr = 1;
34365                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
34366                                 if (RETURN_VALUE_USED(opline)) {
34367                                         PZVAL_LOCK(*zptr);
34368                                         EX_T(opline->result.var).var.ptr = *zptr;
34369                                 }
34370                         }
34371                 }
34372 
34373                 if (!have_get_ptr) {
34374                         zval *z = NULL;
34375 
34376                         Z_ADDREF_P(object);
34377                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
34378                                 if (Z_OBJ_HT_P(object)->read_property) {
34379                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34380                                 }
34381                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
34382                                 if (Z_OBJ_HT_P(object)->read_dimension) {
34383                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
34384                                 }
34385                         }
34386                         if (z) {
34387                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
34388                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
34389 
34390                                         if (Z_REFCOUNT_P(z) == 0) {
34391                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
34392                                                 zval_dtor(z);
34393                                                 FREE_ZVAL(z);
34394                                         }
34395                                         z = value;
34396                                 }
34397                                 Z_ADDREF_P(z);
34398                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
34399                                 binary_op(z, z, value TSRMLS_CC);
34400                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
34401                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34402                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
34403                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
34404                                 }
34405                                 if (RETURN_VALUE_USED(opline)) {
34406                                         PZVAL_LOCK(z);
34407                                         EX_T(opline->result.var).var.ptr = z;
34408                                 }
34409                                 zval_ptr_dtor(&z);
34410                         } else {
34411                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
34412                                 if (RETURN_VALUE_USED(opline)) {
34413                                         PZVAL_LOCK(&EG(uninitialized_zval));
34414                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34415                                 }
34416                         }
34417                         zval_ptr_dtor(&object);
34418                 }
34419 
34420                 if (1) {
34421                         zval_ptr_dtor(&property);
34422                 } else {
34423                         zval_dtor(free_op2.var);
34424                 }
34425                 FREE_OP(free_op_data1);
34426         }
34427 
34428         /* assign_obj has two opcodes! */
34429         CHECK_EXCEPTION();
34430         ZEND_VM_INC_OPCODE();
34431         ZEND_VM_NEXT_OPCODE();
34432 }
34433 
34434 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
34435 {
34436         USE_OPLINE
34437         zend_free_op free_op2, free_op_data2, free_op_data1;
34438         zval **var_ptr;
34439         zval *value;
34440 
34441         SAVE_OPLINE();
34442         switch (opline->extended_value) {
34443                 case ZEND_ASSIGN_OBJ:
34444                         return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34445                         break;
34446                 case ZEND_ASSIGN_DIM: {
34447                                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34448 
34449                                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
34450                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
34451                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
34452                                         if (IS_CV == IS_VAR && !0) {
34453                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
34454                                         }
34455                                         return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34456                                 } else {
34457                                         zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34458 
34459                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
34460                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
34461                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
34462                                 }
34463                         }
34464                         break;
34465                 default:
34466                         value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34467                         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34468                         /* do nothing */
34469                         break;
34470         }
34471 
34472         if (UNEXPECTED(var_ptr == NULL)) {
34473                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
34474         }
34475 
34476         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
34477                 if (RETURN_VALUE_USED(opline)) {
34478                         PZVAL_LOCK(&EG(uninitialized_zval));
34479                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34480                 }
34481                 zval_dtor(free_op2.var);
34482 
34483                 CHECK_EXCEPTION();
34484                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
34485                         ZEND_VM_INC_OPCODE();
34486                 }
34487                 ZEND_VM_NEXT_OPCODE();
34488         }
34489 
34490         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
34491 
34492         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
34493            && Z_OBJ_HANDLER_PP(var_ptr, get)
34494            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
34495                 /* proxy object */
34496                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
34497                 Z_ADDREF_P(objval);
34498                 binary_op(objval, objval, value TSRMLS_CC);
34499                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
34500                 zval_ptr_dtor(&objval);
34501         } else {
34502                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
34503         }
34504 
34505         if (RETURN_VALUE_USED(opline)) {
34506                 PZVAL_LOCK(*var_ptr);
34507                 EX_T(opline->result.var).var.ptr = *var_ptr;
34508         }
34509         zval_dtor(free_op2.var);
34510 
34511         if (opline->extended_value == ZEND_ASSIGN_DIM) {
34512                 FREE_OP(free_op_data1);
34513                 FREE_OP_VAR_PTR(free_op_data2);
34514 
34515                 CHECK_EXCEPTION();
34516                 ZEND_VM_INC_OPCODE();
34517         } else {
34518 
34519                 CHECK_EXCEPTION();
34520         }
34521         ZEND_VM_NEXT_OPCODE();
34522 }
34523 
34524 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34525 {
34526         return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34527 }
34528 
34529 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34530 {
34531         return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34532 }
34533 
34534 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34535 {
34536         return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34537 }
34538 
34539 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34540 {
34541         return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34542 }
34543 
34544 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34545 {
34546         return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34547 }
34548 
34549 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34550 {
34551         return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34552 }
34553 
34554 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34555 {
34556         return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34557 }
34558 
34559 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34560 {
34561         return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34562 }
34563 
34564 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34565 {
34566         return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34567 }
34568 
34569 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34570 {
34571         return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34572 }
34573 
34574 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34575 {
34576         return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34577 }
34578 
34579 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
34580 {
34581         USE_OPLINE
34582         zend_free_op free_op2;
34583         zval **object_ptr;
34584         zval *object;
34585         zval *property;
34586         zval **retval;
34587         int have_get_ptr = 0;
34588 
34589         SAVE_OPLINE();
34590         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34591         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34592         retval = &EX_T(opline->result.var).var.ptr;
34593 
34594         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
34595                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
34596         }
34597 
34598         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
34599         object = *object_ptr;
34600 
34601         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34602                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
34603                 zval_dtor(free_op2.var);
34604                 if (RETURN_VALUE_USED(opline)) {
34605                         PZVAL_LOCK(&EG(uninitialized_zval));
34606                         *retval = &EG(uninitialized_zval);
34607                 }
34608 
34609                 CHECK_EXCEPTION();
34610                 ZEND_VM_NEXT_OPCODE();
34611         }
34612 
34613         /* here we are sure we are dealing with an object */
34614 
34615         if (1) {
34616                 MAKE_REAL_ZVAL_PTR(property);
34617         }
34618 
34619         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
34620                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34621                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
34622                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
34623 
34624                         have_get_ptr = 1;
34625                         incdec_op(*zptr);
34626                         if (RETURN_VALUE_USED(opline)) {
34627                                 *retval = *zptr;
34628                                 PZVAL_LOCK(*retval);
34629                         }
34630                 }
34631         }
34632 
34633         if (!have_get_ptr) {
34634                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
34635                         zval *z;
34636 
34637                         Z_ADDREF_P(object);
34638                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34639 
34640                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
34641                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
34642 
34643                                 if (Z_REFCOUNT_P(z) == 0) {
34644                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
34645                                         zval_dtor(z);
34646                                         FREE_ZVAL(z);
34647                                 }
34648                                 z = value;
34649                         }
34650                         Z_ADDREF_P(z);
34651                         SEPARATE_ZVAL_IF_NOT_REF(&z);
34652                         incdec_op(z);
34653                         *retval = z;
34654                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34655                         zval_ptr_dtor(&object);
34656                         SELECTIVE_PZVAL_LOCK(*retval, opline);
34657                         zval_ptr_dtor(&z);
34658                 } else {
34659                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
34660                         if (RETURN_VALUE_USED(opline)) {
34661                                 PZVAL_LOCK(&EG(uninitialized_zval));
34662                                 *retval = &EG(uninitialized_zval);
34663                         }
34664                 }
34665         }
34666 
34667         if (1) {
34668                 zval_ptr_dtor(&property);
34669         } else {
34670                 zval_dtor(free_op2.var);
34671         }
34672 
34673         CHECK_EXCEPTION();
34674         ZEND_VM_NEXT_OPCODE();
34675 }
34676 
34677 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34678 {
34679         return zend_pre_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34680 }
34681 
34682 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34683 {
34684         return zend_pre_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34685 }
34686 
34687 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
34688 {
34689         USE_OPLINE
34690         zend_free_op free_op2;
34691         zval **object_ptr;
34692         zval *object;
34693         zval *property;
34694         zval *retval;
34695         int have_get_ptr = 0;
34696 
34697         SAVE_OPLINE();
34698         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34699         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34700         retval = &EX_T(opline->result.var).tmp_var;
34701 
34702         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
34703                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
34704         }
34705 
34706         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
34707         object = *object_ptr;
34708 
34709         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34710                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
34711                 zval_dtor(free_op2.var);
34712                 ZVAL_NULL(retval);
34713 
34714                 CHECK_EXCEPTION();
34715                 ZEND_VM_NEXT_OPCODE();
34716         }
34717 
34718         /* here we are sure we are dealing with an object */
34719 
34720         if (1) {
34721                 MAKE_REAL_ZVAL_PTR(property);
34722         }
34723 
34724         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
34725                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34726                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
34727                         have_get_ptr = 1;
34728                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
34729 
34730                         ZVAL_COPY_VALUE(retval, *zptr);
34731                         zendi_zval_copy_ctor(*retval);
34732 
34733                         incdec_op(*zptr);
34734 
34735                 }
34736         }
34737 
34738         if (!have_get_ptr) {
34739                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
34740                         zval *z, *z_copy;
34741 
34742                         Z_ADDREF_P(object);
34743                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34744                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
34745                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
34746 
34747                                 if (Z_REFCOUNT_P(z) == 0) {
34748                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
34749                                         zval_dtor(z);
34750                                         FREE_ZVAL(z);
34751                                 }
34752                                 z = value;
34753                         }
34754                         ZVAL_COPY_VALUE(retval, z);
34755                         zendi_zval_copy_ctor(*retval);
34756                         ALLOC_ZVAL(z_copy);
34757                         INIT_PZVAL_COPY(z_copy, z);
34758                         zendi_zval_copy_ctor(*z_copy);
34759                         incdec_op(z_copy);
34760                         Z_ADDREF_P(z);
34761                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34762                         zval_ptr_dtor(&object);
34763                         zval_ptr_dtor(&z_copy);
34764                         zval_ptr_dtor(&z);
34765                 } else {
34766                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
34767                         ZVAL_NULL(retval);
34768                 }
34769         }
34770 
34771         if (1) {
34772                 zval_ptr_dtor(&property);
34773         } else {
34774                 zval_dtor(free_op2.var);
34775         }
34776 
34777         CHECK_EXCEPTION();
34778         ZEND_VM_NEXT_OPCODE();
34779 }
34780 
34781 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34782 {
34783         return zend_post_incdec_property_helper_SPEC_CV_TMP(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34784 }
34785 
34786 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34787 {
34788         return zend_post_incdec_property_helper_SPEC_CV_TMP(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34789 }
34790 
34791 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34792 {
34793         USE_OPLINE
34794         zend_free_op free_op2;
34795         zval *container;
34796 
34797         SAVE_OPLINE();
34798         container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
34799         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
34800         zval_dtor(free_op2.var);
34801         if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
34802 
34803         }
34804         CHECK_EXCEPTION();
34805         ZEND_VM_NEXT_OPCODE();
34806 }
34807 
34808 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34809 {
34810         USE_OPLINE
34811         zend_free_op free_op1, free_op2;
34812         zval **container;
34813 
34814         SAVE_OPLINE();
34815         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
34816 
34817         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
34818                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
34819         }
34820         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
34821         zval_dtor(free_op2.var);
34822         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
34823                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
34824         }
34825 
34826         /* We are going to assign the result by reference */
34827         if (UNEXPECTED(opline->extended_value != 0)) {
34828                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
34829 
34830                 if (retval_ptr) {
34831                         Z_DELREF_PP(retval_ptr);
34832                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
34833                         Z_ADDREF_PP(retval_ptr);
34834                 }
34835         }
34836 
34837         CHECK_EXCEPTION();
34838         ZEND_VM_NEXT_OPCODE();
34839 }
34840 
34841 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34842 {
34843         USE_OPLINE
34844         zend_free_op free_op1, free_op2;
34845         zval **container;
34846 
34847         SAVE_OPLINE();
34848         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
34849 
34850         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
34851                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
34852         }
34853         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
34854         zval_dtor(free_op2.var);
34855         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
34856                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
34857         }
34858 
34859         CHECK_EXCEPTION();
34860         ZEND_VM_NEXT_OPCODE();
34861 }
34862 
34863 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34864 {
34865         USE_OPLINE
34866         zend_free_op free_op2;
34867         zval *container;
34868 
34869         SAVE_OPLINE();
34870         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
34871         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC);
34872         zval_dtor(free_op2.var);
34873 
34874         CHECK_EXCEPTION();
34875         ZEND_VM_NEXT_OPCODE();
34876 }
34877 
34878 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34879 {
34880         USE_OPLINE
34881         zend_free_op free_op1, free_op2;
34882 
34883         SAVE_OPLINE();
34884 
34885         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
34886                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
34887                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
34888                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
34889                 }
34890                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
34891                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
34892                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
34893                 }
34894                 zval_dtor(free_op2.var);
34895 
34896         } else {
34897                 zval *container;
34898 
34899                 if (IS_TMP_VAR == IS_UNUSED) {
34900                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
34901                 }
34902                 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
34903                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
34904                 zval_dtor(free_op2.var);
34905 
34906         }
34907         CHECK_EXCEPTION();
34908         ZEND_VM_NEXT_OPCODE();
34909 }
34910 
34911 static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34912 {
34913         USE_OPLINE
34914         zend_free_op free_op1, free_op2;
34915         zval **container;
34916 
34917         SAVE_OPLINE();
34918         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
34919 
34920         if (IS_CV == IS_CV) {
34921                 if (container != &EG(uninitialized_zval_ptr)) {
34922                         SEPARATE_ZVAL_IF_NOT_REF(container);
34923                 }
34924         }
34925         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
34926                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
34927         }
34928         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC);
34929         zval_dtor(free_op2.var);
34930         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
34931                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
34932         }
34933 
34934         if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
34935                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
34936                 ZEND_VM_NEXT_OPCODE();
34937         } else {
34938                 zend_free_op free_res;
34939                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
34940 
34941                 PZVAL_UNLOCK(*retval_ptr, &free_res);
34942                 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
34943                         SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
34944                 }
34945                 PZVAL_LOCK(*retval_ptr);
34946                 FREE_OP_VAR_PTR(free_res);
34947                 CHECK_EXCEPTION();
34948                 ZEND_VM_NEXT_OPCODE();
34949         }
34950 }
34951 
34952 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS)
34953 {
34954         USE_OPLINE
34955 
34956         zval *container;
34957         zend_free_op free_op2;
34958         zval *offset;
34959 
34960         SAVE_OPLINE();
34961         container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
34962         offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
34963 
34964         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
34965             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
34966                 zend_error(E_NOTICE, "Trying to get property of non-object");
34967                 PZVAL_LOCK(&EG(uninitialized_zval));
34968                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
34969                 zval_dtor(free_op2.var);
34970         } else {
34971                 zval *retval;
34972 
34973                 if (1) {
34974                         MAKE_REAL_ZVAL_PTR(offset);
34975                 }
34976 
34977                 /* here we are sure we are dealing with an object */
34978                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
34979 
34980                 PZVAL_LOCK(retval);
34981                 EX_T(opline->result.var).var.ptr = retval;
34982 
34983                 if (1) {
34984                         zval_ptr_dtor(&offset);
34985                 } else {
34986                         zval_dtor(free_op2.var);
34987                 }
34988         }
34989 
34990         CHECK_EXCEPTION();
34991         ZEND_VM_NEXT_OPCODE();
34992 }
34993 
34994 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34995 {
34996         return zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
34997 }
34998 
34999 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35000 {
35001         USE_OPLINE
35002         zend_free_op free_op1, free_op2;
35003         zval *property;
35004         zval **container;
35005 
35006         SAVE_OPLINE();
35007         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35008 
35009         if (1) {
35010                 MAKE_REAL_ZVAL_PTR(property);
35011         }
35012         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35013         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35014                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
35015         }
35016 
35017         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
35018         if (1) {
35019                 zval_ptr_dtor(&property);
35020         } else {
35021                 zval_dtor(free_op2.var);
35022         }
35023         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35024                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35025         }
35026 
35027         /* We are going to assign the result by reference */
35028         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
35029                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
35030 
35031                 Z_DELREF_PP(retval_ptr);
35032                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
35033                 Z_ADDREF_PP(retval_ptr);
35034                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
35035                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
35036         }
35037 
35038         CHECK_EXCEPTION();
35039         ZEND_VM_NEXT_OPCODE();
35040 }
35041 
35042 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35043 {
35044         USE_OPLINE
35045         zend_free_op free_op1, free_op2;
35046         zval *property;
35047         zval **container;
35048 
35049         SAVE_OPLINE();
35050         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35051         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
35052 
35053         if (1) {
35054                 MAKE_REAL_ZVAL_PTR(property);
35055         }
35056         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35057                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
35058         }
35059         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
35060         if (1) {
35061                 zval_ptr_dtor(&property);
35062         } else {
35063                 zval_dtor(free_op2.var);
35064         }
35065         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35066                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35067         }
35068 
35069         CHECK_EXCEPTION();
35070         ZEND_VM_NEXT_OPCODE();
35071 }
35072 
35073 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35074 {
35075         USE_OPLINE
35076 
35077         zval *container;
35078         zend_free_op free_op2;
35079         zval *offset;
35080 
35081         SAVE_OPLINE();
35082         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
35083         offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35084 
35085         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
35086             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
35087                 PZVAL_LOCK(&EG(uninitialized_zval));
35088                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35089                 zval_dtor(free_op2.var);
35090         } else {
35091                 zval *retval;
35092 
35093                 if (1) {
35094                         MAKE_REAL_ZVAL_PTR(offset);
35095                 }
35096 
35097                 /* here we are sure we are dealing with an object */
35098                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35099 
35100                 PZVAL_LOCK(retval);
35101                 EX_T(opline->result.var).var.ptr = retval;
35102 
35103                 if (1) {
35104                         zval_ptr_dtor(&offset);
35105                 } else {
35106                         zval_dtor(free_op2.var);
35107                 }
35108         }
35109 
35110         CHECK_EXCEPTION();
35111         ZEND_VM_NEXT_OPCODE();
35112 }
35113 
35114 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35115 {
35116         USE_OPLINE
35117 
35118         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
35119                 /* Behave like FETCH_OBJ_W */
35120                 zend_free_op free_op1, free_op2;
35121                 zval *property;
35122                 zval **container;
35123 
35124                 SAVE_OPLINE();
35125                 property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35126                 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35127 
35128                 if (1) {
35129                         MAKE_REAL_ZVAL_PTR(property);
35130                 }
35131                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35132                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
35133                 }
35134                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
35135                 if (1) {
35136                         zval_ptr_dtor(&property);
35137                 } else {
35138                         zval_dtor(free_op2.var);
35139                 }
35140                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35141                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35142                 }
35143 
35144                 CHECK_EXCEPTION();
35145                 ZEND_VM_NEXT_OPCODE();
35146         } else {
35147                 return zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35148         }
35149 }
35150 
35151 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35152 {
35153         USE_OPLINE
35154         zend_free_op free_op1, free_op2, free_res;
35155         zval **container;
35156         zval *property;
35157 
35158         SAVE_OPLINE();
35159         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
35160         property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35161 
35162         if (IS_CV == IS_CV) {
35163                 if (container != &EG(uninitialized_zval_ptr)) {
35164                         SEPARATE_ZVAL_IF_NOT_REF(container);
35165                 }
35166         }
35167         if (1) {
35168                 MAKE_REAL_ZVAL_PTR(property);
35169         }
35170         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
35171                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
35172         }
35173         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
35174         if (1) {
35175                 zval_ptr_dtor(&property);
35176         } else {
35177                 zval_dtor(free_op2.var);
35178         }
35179         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
35180                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
35181         }
35182 
35183         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
35184         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
35185                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
35186         }
35187         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
35188         FREE_OP_VAR_PTR(free_res);
35189         CHECK_EXCEPTION();
35190         ZEND_VM_NEXT_OPCODE();
35191 }
35192 
35193 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35194 {
35195         USE_OPLINE
35196         zend_free_op free_op2;
35197         zval **object_ptr;
35198         zval *property_name;
35199 
35200         SAVE_OPLINE();
35201         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35202         property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35203 
35204         if (1) {
35205                 MAKE_REAL_ZVAL_PTR(property_name);
35206         }
35207         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
35208                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
35209         }
35210         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35211         if (1) {
35212                 zval_ptr_dtor(&property_name);
35213         } else {
35214                 zval_dtor(free_op2.var);
35215         }
35216 
35217         /* assign_obj has two opcodes! */
35218         CHECK_EXCEPTION();
35219         ZEND_VM_INC_OPCODE();
35220         ZEND_VM_NEXT_OPCODE();
35221 }
35222 
35223 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35224 {
35225         USE_OPLINE
35226 
35227         zval **object_ptr;
35228 
35229         SAVE_OPLINE();
35230         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35231 
35232         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
35233                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
35234         }
35235         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
35236                 zend_free_op free_op2;
35237                 zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35238 
35239                 if (1) {
35240                         MAKE_REAL_ZVAL_PTR(property_name);
35241                 }
35242                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35243                 if (1) {
35244                         zval_ptr_dtor(&property_name);
35245                 } else {
35246                         zval_dtor(free_op2.var);
35247                 }
35248         } else {
35249                 zend_free_op free_op2, free_op_data1, free_op_data2;
35250                 zval *value;
35251                 zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35252                 zval **variable_ptr_ptr;
35253 
35254                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
35255                 zval_dtor(free_op2.var);
35256 
35257                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
35258                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
35259                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
35260                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
35261                                 if (RETURN_VALUE_USED(opline)) {
35262                                         zval *retval;
35263 
35264                                         ALLOC_ZVAL(retval);
35265                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
35266                                         INIT_PZVAL(retval);
35267                                         EX_T(opline->result.var).var.ptr = retval;
35268                                 }
35269                         } else if (RETURN_VALUE_USED(opline)) {
35270                                 PZVAL_LOCK(&EG(uninitialized_zval));
35271                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35272                         }
35273                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
35274                         if (IS_TMP_FREE(free_op_data1)) {
35275                                 zval_dtor(value);
35276                         }
35277                         if (RETURN_VALUE_USED(opline)) {
35278                                 PZVAL_LOCK(&EG(uninitialized_zval));
35279                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35280                         }
35281                 } else {
35282                         if ((opline+1)->op1_type == IS_TMP_VAR) {
35283                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35284                         } else if ((opline+1)->op1_type == IS_CONST) {
35285                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35286                         } else {
35287                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35288                         }
35289                         if (RETURN_VALUE_USED(opline)) {
35290                                 PZVAL_LOCK(value);
35291                                 EX_T(opline->result.var).var.ptr = value;
35292                         }
35293                 }
35294                 FREE_OP_VAR_PTR(free_op_data2);
35295                 FREE_OP_IF_VAR(free_op_data1);
35296         }
35297 
35298         /* assign_dim has two opcodes! */
35299         CHECK_EXCEPTION();
35300         ZEND_VM_INC_OPCODE();
35301         ZEND_VM_NEXT_OPCODE();
35302 }
35303 
35304 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35305 {
35306         USE_OPLINE
35307         zend_free_op free_op2;
35308         zval *value;
35309         zval **variable_ptr_ptr;
35310 
35311         SAVE_OPLINE();
35312         value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35313         variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35314 
35315         if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
35316                 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
35317                         if (RETURN_VALUE_USED(opline)) {
35318                                 zval *retval;
35319 
35320                                 ALLOC_ZVAL(retval);
35321                                 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
35322                                 INIT_PZVAL(retval);
35323                                 EX_T(opline->result.var).var.ptr = retval;
35324                         }
35325                 } else if (RETURN_VALUE_USED(opline)) {
35326                         PZVAL_LOCK(&EG(uninitialized_zval));
35327                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35328                 }
35329         } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
35330                 if (1) {
35331                         zval_dtor(value);
35332                 }
35333                 if (RETURN_VALUE_USED(opline)) {
35334                         PZVAL_LOCK(&EG(uninitialized_zval));
35335                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35336                 }
35337         } else {
35338                 if (IS_TMP_VAR == IS_TMP_VAR) {
35339                         value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35340                 } else if (IS_TMP_VAR == IS_CONST) {
35341                         value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35342                 } else {
35343                         value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
35344                 }
35345                 if (RETURN_VALUE_USED(opline)) {
35346                         PZVAL_LOCK(value);
35347                         EX_T(opline->result.var).var.ptr = value;
35348                 }
35349         }
35350 
35351         if (IS_CV == IS_VAR && 0) {
35352                 zval_ptr_dtor_nogc(&value);
35353         }
35354 
35355         /* zend_assign_to_variable() always takes care of op2, never free it! */
35356 
35357         CHECK_EXCEPTION();
35358         ZEND_VM_NEXT_OPCODE();
35359 }
35360 
35361 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35362 {
35363         USE_OPLINE
35364         zval *function_name;
35365         char *function_name_strval;
35366         int function_name_strlen;
35367         zend_free_op free_op2;
35368         call_slot *call = EX(call_slots) + opline->result.num;
35369 
35370         SAVE_OPLINE();
35371 
35372         function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35373 
35374         if (IS_TMP_VAR != IS_CONST &&
35375             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
35376                 if (UNEXPECTED(EG(exception) != NULL)) {
35377                         HANDLE_EXCEPTION();
35378                 }
35379                 zend_error_noreturn(E_ERROR, "Method name must be a string");
35380         }
35381 
35382         function_name_strval = Z_STRVAL_P(function_name);
35383         function_name_strlen = Z_STRLEN_P(function_name);
35384 
35385         call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35386 
35387         if (EXPECTED(call->object != NULL) &&
35388             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
35389                 call->called_scope = Z_OBJCE_P(call->object);
35390 
35391                 if (IS_TMP_VAR != IS_CONST ||
35392                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
35393                     zval *object = call->object;
35394 
35395                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
35396                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
35397                         }
35398 
35399                         /* First, locate the function. */
35400                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
35401                         if (UNEXPECTED(call->fbc == NULL)) {
35402                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
35403                         }
35404                         if (IS_TMP_VAR == IS_CONST &&
35405                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
35406                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
35407                             EXPECTED(call->object == object)) {
35408                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
35409                         }
35410                 }
35411         } else {
35412                 if (UNEXPECTED(EG(exception) != NULL)) {
35413                         zval_dtor(free_op2.var);
35414                         HANDLE_EXCEPTION();
35415                 }
35416                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
35417         }
35418 
35419         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
35420                 call->object = NULL;
35421         } else {
35422                 if (!PZVAL_IS_REF(call->object)) {
35423                         Z_ADDREF_P(call->object); /* For $this pointer */
35424                 } else {
35425                         zval *this_ptr;
35426                         ALLOC_ZVAL(this_ptr);
35427                         INIT_PZVAL_COPY(this_ptr, call->object);
35428                         zval_copy_ctor(this_ptr);
35429                         call->object = this_ptr;
35430                 }
35431         }
35432 
35433         call->num_additional_args = 0;
35434         call->is_ctor_call = 0;
35435         EX(call) = call;
35436 
35437         zval_dtor(free_op2.var);
35438 
35439         CHECK_EXCEPTION();
35440         ZEND_VM_NEXT_OPCODE();
35441 }
35442 
35443 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35444 {
35445         USE_OPLINE
35446         zend_free_op free_op2;
35447 
35448         SAVE_OPLINE();
35449         is_equal_function(&EX_T(opline->result.var).tmp_var,
35450                                  _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
35451                                  _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
35452 
35453         zval_dtor(free_op2.var);
35454         CHECK_EXCEPTION();
35455         ZEND_VM_NEXT_OPCODE();
35456 }
35457 
35458 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35459 {
35460         USE_OPLINE
35461 
35462         zval *expr_ptr;
35463 
35464         SAVE_OPLINE();
35465         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
35466                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35467 
35468                 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
35469                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
35470                 }
35471                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
35472                 expr_ptr = *expr_ptr_ptr;
35473                 Z_ADDREF_P(expr_ptr);
35474         } else {
35475                 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35476                 if (0) { /* temporary variable */
35477                         zval *new_expr;
35478 
35479                         ALLOC_ZVAL(new_expr);
35480                         INIT_PZVAL_COPY(new_expr, expr_ptr);
35481                         expr_ptr = new_expr;
35482                 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
35483                         zval *new_expr;
35484 
35485                         ALLOC_ZVAL(new_expr);
35486                         INIT_PZVAL_COPY(new_expr, expr_ptr);
35487                         expr_ptr = new_expr;
35488                         zendi_zval_copy_ctor(*expr_ptr);
35489 
35490                 } else if (IS_CV == IS_CV) {
35491                         Z_ADDREF_P(expr_ptr);
35492                 }
35493         }
35494 
35495         if (IS_TMP_VAR != IS_UNUSED) {
35496                 zend_free_op free_op2;
35497                 zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35498                 ulong hval;
35499 
35500                 switch (Z_TYPE_P(offset)) {
35501                         case IS_DOUBLE:
35502                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
35503                                 goto num_index;
35504                         case IS_LONG:
35505                         case IS_BOOL:
35506                                 hval = Z_LVAL_P(offset);
35507 num_index:
35508                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
35509                                 break;
35510                         case IS_STRING:
35511                                 if (IS_TMP_VAR == IS_CONST) {
35512                                         hval = Z_HASH_P(offset);
35513                                 } else {
35514                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
35515                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
35516                                 }
35517                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
35518                                 break;
35519                         case IS_NULL:
35520                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
35521                                 break;
35522                         default:
35523                                 zend_error(E_WARNING, "Illegal offset type");
35524                                 zval_ptr_dtor(&expr_ptr);
35525                                 /* do nothing */
35526                                 break;
35527                 }
35528                 zval_dtor(free_op2.var);
35529         } else {
35530                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
35531         }
35532         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
35533 
35534         }
35535         CHECK_EXCEPTION();
35536         ZEND_VM_NEXT_OPCODE();
35537 }
35538 
35539 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35540 {
35541         USE_OPLINE
35542 
35543         array_init(&EX_T(opline->result.var).tmp_var);
35544         if (IS_CV == IS_UNUSED) {
35545                 ZEND_VM_NEXT_OPCODE();
35546 #if 0 || IS_CV != IS_UNUSED
35547         } else {
35548                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35549 #endif
35550         }
35551 }
35552 
35553 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35554 {
35555         USE_OPLINE
35556         zend_free_op free_op2;
35557         zval **container;
35558         zval *offset;
35559         ulong hval;
35560 
35561         SAVE_OPLINE();
35562         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
35563         if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
35564                 SEPARATE_ZVAL_IF_NOT_REF(container);
35565         }
35566         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35567 
35568         if (IS_CV != IS_VAR || container) {
35569                 switch (Z_TYPE_PP(container)) {
35570                         case IS_ARRAY: {
35571                                 HashTable *ht = Z_ARRVAL_PP(container);
35572 
35573                                 switch (Z_TYPE_P(offset)) {
35574                                         case IS_DOUBLE:
35575                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
35576                                                 zend_hash_index_del(ht, hval);
35577                                                 break;
35578                                         case IS_RESOURCE:
35579                                         case IS_BOOL:
35580                                         case IS_LONG:
35581                                                 hval = Z_LVAL_P(offset);
35582                                                 zend_hash_index_del(ht, hval);
35583                                                 break;
35584                                         case IS_STRING:
35585                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
35586                                                         Z_ADDREF_P(offset);
35587                                                 }
35588                                                 if (IS_TMP_VAR == IS_CONST) {
35589                                                         hval = Z_HASH_P(offset);
35590                                                 } else {
35591                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
35592                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
35593                                                 }
35594                                                 if (ht == &EG(symbol_table)) {
35595                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
35596                                                 } else {
35597                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
35598                                                 }
35599                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
35600                                                         zval_ptr_dtor(&offset);
35601                                                 }
35602                                                 break;
35603 num_index_dim:
35604                                                 zend_hash_index_del(ht, hval);
35605                                                 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
35606                                                         zval_ptr_dtor(&offset);
35607                                                 }
35608                                                 break;
35609                                         case IS_NULL:
35610                                                 zend_hash_del(ht, "", sizeof(""));
35611                                                 break;
35612                                         default:
35613                                                 zend_error(E_WARNING, "Illegal offset type in unset");
35614                                                 break;
35615                                 }
35616                                 zval_dtor(free_op2.var);
35617                                 break;
35618                         }
35619                         case IS_OBJECT:
35620                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
35621                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
35622                                 }
35623                                 if (1) {
35624                                         MAKE_REAL_ZVAL_PTR(offset);
35625                                 }
35626                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
35627                                 if (1) {
35628                                         zval_ptr_dtor(&offset);
35629                                 } else {
35630                                         zval_dtor(free_op2.var);
35631                                 }
35632                                 break;
35633                         case IS_STRING:
35634                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
35635                                 ZEND_VM_CONTINUE(); /* bailed out before */
35636                         default:
35637                                 zval_dtor(free_op2.var);
35638                                 break;
35639                 }
35640         } else {
35641                 zval_dtor(free_op2.var);
35642         }
35643 
35644         CHECK_EXCEPTION();
35645         ZEND_VM_NEXT_OPCODE();
35646 }
35647 
35648 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35649 {
35650         USE_OPLINE
35651         zend_free_op free_op2;
35652         zval **container;
35653         zval *offset;
35654 
35655         SAVE_OPLINE();
35656         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
35657         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35658 
35659         if (IS_CV != IS_VAR || container) {
35660                 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
35661                         SEPARATE_ZVAL_IF_NOT_REF(container);
35662                 }
35663                 if (Z_TYPE_PP(container) == IS_OBJECT) {
35664                         if (1) {
35665                                 MAKE_REAL_ZVAL_PTR(offset);
35666                         }
35667                         if (Z_OBJ_HT_P(*container)->unset_property) {
35668                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35669                         } else {
35670                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
35671                         }
35672                         if (1) {
35673                                 zval_ptr_dtor(&offset);
35674                         } else {
35675                                 zval_dtor(free_op2.var);
35676                         }
35677                 } else {
35678                         zval_dtor(free_op2.var);
35679                 }
35680         } else {
35681                 zval_dtor(free_op2.var);
35682         }
35683 
35684         CHECK_EXCEPTION();
35685         ZEND_VM_NEXT_OPCODE();
35686 }
35687 
35688 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
35689 {
35690         USE_OPLINE
35691         zend_free_op free_op2;
35692         zval *container;
35693         zval **value = NULL;
35694         int result = 0;
35695         ulong hval;
35696         zval *offset;
35697 
35698         SAVE_OPLINE();
35699         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
35700         offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35701 
35702         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
35703                 HashTable *ht;
35704                 int isset = 0;
35705 
35706                 ht = Z_ARRVAL_P(container);
35707 
35708                 switch (Z_TYPE_P(offset)) {
35709                         case IS_DOUBLE:
35710                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
35711                                 goto num_index_prop;
35712                         case IS_RESOURCE:
35713                         case IS_BOOL:
35714                         case IS_LONG:
35715                                 hval = Z_LVAL_P(offset);
35716 num_index_prop:
35717                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
35718                                         isset = 1;
35719                                 }
35720                                 break;
35721                         case IS_STRING:
35722                                 if (IS_TMP_VAR == IS_CONST) {
35723                                         hval = Z_HASH_P(offset);
35724                                 } else {
35725                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
35726                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
35727                                 }
35728                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
35729                                         isset = 1;
35730                                 }
35731                                 break;
35732                         case IS_NULL:
35733                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
35734                                         isset = 1;
35735                                 }
35736                                 break;
35737                         default:
35738                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
35739                                 break;
35740                 }
35741 
35742                 if (opline->extended_value & ZEND_ISSET) {
35743                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
35744                                 result = 0;
35745                         } else {
35746                                 result = isset;
35747                         }
35748                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
35749                         if (!isset || !i_zend_is_true(*value)) {
35750                                 result = 0;
35751                         } else {
35752                                 result = 1;
35753                         }
35754                 }
35755                 zval_dtor(free_op2.var);
35756         } else if (Z_TYPE_P(container) == IS_OBJECT) {
35757                 if (1) {
35758                         MAKE_REAL_ZVAL_PTR(offset);
35759                 }
35760                 if (prop_dim) {
35761                         if (Z_OBJ_HT_P(container)->has_property) {
35762                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
35763                         } else {
35764                                 zend_error(E_NOTICE, "Trying to check property of non-object");
35765                                 result = 0;
35766                         }
35767                 } else {
35768                         if (Z_OBJ_HT_P(container)->has_dimension) {
35769                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
35770                         } else {
35771                                 zend_error(E_NOTICE, "Trying to check element of non-array");
35772                                 result = 0;
35773                         }
35774                 }
35775                 if (1) {
35776                         zval_ptr_dtor(&offset);
35777                 } else {
35778                         zval_dtor(free_op2.var);
35779                 }
35780         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
35781                 zval tmp;
35782 
35783                 if (Z_TYPE_P(offset) != IS_LONG) {
35784                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
35785                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
35786                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
35787                                 ZVAL_COPY_VALUE(&tmp, offset);
35788                                 zval_copy_ctor(&tmp);
35789                                 convert_to_long(&tmp);
35790                                 offset = &tmp;
35791                         } else {
35792                                 /* can not be converted to proper offset, return "not set" */
35793                                 result = 0;
35794                         }
35795                 }
35796                 if (Z_TYPE_P(offset) == IS_LONG) {
35797                         if (opline->extended_value & ZEND_ISSET) {
35798                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
35799                                         result = 1;
35800                                 }
35801                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
35802                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
35803                                         result = 1;
35804                                 }
35805                         }
35806                 }
35807                 zval_dtor(free_op2.var);
35808         } else {
35809                 zval_dtor(free_op2.var);
35810         }
35811 
35812         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
35813         if (opline->extended_value & ZEND_ISSET) {
35814                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
35815         } else {
35816                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
35817         }
35818 
35819         CHECK_EXCEPTION();
35820         ZEND_VM_NEXT_OPCODE();
35821 }
35822 
35823 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35824 {
35825         return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35826 }
35827 
35828 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35829 {
35830         return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
35831 }
35832 
35833 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35834 {
35835         USE_OPLINE
35836 
35837         /* The generator object is stored in return_value_ptr_ptr */
35838         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
35839 
35840         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
35841                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
35842         }
35843 
35844         /* Destroy the previously yielded value */
35845         if (generator->value) {
35846                 zval_ptr_dtor(&generator->value);
35847         }
35848 
35849         /* Destroy the previously yielded key */
35850         if (generator->key) {
35851                 zval_ptr_dtor(&generator->key);
35852         }
35853 
35854         /* Set the new yielded value */
35855         if (IS_CV != IS_UNUSED) {
35856 
35857 
35858                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
35859                         /* Constants and temporary variables aren't yieldable by reference,
35860                          * but we still allow them with a notice. */
35861                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
35862                                 zval *value, *copy;
35863 
35864                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35865 
35866                                 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35867                                 ALLOC_ZVAL(copy);
35868                                 INIT_PZVAL_COPY(copy, value);
35869 
35870                                 /* Temporary variables don't need ctor copying */
35871                                 if (!0) {
35872                                         zval_copy_ctor(copy);
35873                                 }
35874 
35875                                 generator->value = copy;
35876                         } else {
35877                                 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
35878 
35879                                 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
35880                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
35881                                 }
35882 
35883                                 /* If a function call result is yielded and the function did
35884                                  * not return by reference we throw a notice. */
35885                                 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
35886                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
35887                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
35888                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
35889                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35890 
35891                                         Z_ADDREF_PP(value_ptr);
35892                                         generator->value = *value_ptr;
35893                                 } else {
35894                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
35895                                         Z_ADDREF_PP(value_ptr);
35896                                         generator->value = *value_ptr;
35897                                 }
35898 
35899                         }
35900                 } else {
35901                         zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
35902 
35903                         /* Consts, temporary variables and references need copying */
35904                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
35905                                 || PZVAL_IS_REF(value)
35906                         ) {
35907                                 zval *copy;
35908 
35909                                 ALLOC_ZVAL(copy);
35910                                 INIT_PZVAL_COPY(copy, value);
35911 
35912                                 /* Temporary variables don't need ctor copying */
35913                                 if (!0) {
35914                                         zval_copy_ctor(copy);
35915                                 }
35916 
35917                                 generator->value = copy;
35918 
35919                         } else {
35920                                 if (IS_CV == IS_CV) {
35921                                         Z_ADDREF_P(value);
35922                                 }
35923                                 generator->value = value;
35924                         }
35925                 }
35926         } else {
35927                 /* If no value was specified yield null */
35928                 Z_ADDREF(EG(uninitialized_zval));
35929                 generator->value = &EG(uninitialized_zval);
35930         }
35931 
35932         /* Set the new yielded key */
35933         if (IS_TMP_VAR != IS_UNUSED) {
35934                 zend_free_op free_op2;
35935                 zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
35936 
35937                 /* Consts, temporary variables and references need copying */
35938                 if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
35939                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
35940                 ) {
35941                         zval *copy;
35942 
35943                         ALLOC_ZVAL(copy);
35944                         INIT_PZVAL_COPY(copy, key);
35945 
35946                         /* Temporary variables don't need ctor copying */
35947                         if (!1) {
35948                                 zval_copy_ctor(copy);
35949                         }
35950 
35951                         generator->key = copy;
35952                 } else {
35953                         Z_ADDREF_P(key);
35954                         generator->key = key;
35955                 }
35956 
35957                 if (Z_TYPE_P(generator->key) == IS_LONG
35958                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
35959                 ) {
35960                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
35961                 }
35962 
35963         } else {
35964                 /* If no key was specified we use auto-increment keys */
35965                 generator->largest_used_integer_key++;
35966 
35967                 ALLOC_INIT_ZVAL(generator->key);
35968                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
35969         }
35970 
35971         if (RETURN_VALUE_USED(opline)) {
35972                 /* If the return value of yield is used set the send
35973                  * target and initialize it to NULL */
35974                 generator->send_target = &EX_T(opline->result.var).var.ptr;
35975                 Z_ADDREF(EG(uninitialized_zval));
35976                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
35977         } else {
35978                 generator->send_target = NULL;
35979         }
35980 
35981         /* We increment to the next op, so we are at the correct position when the
35982          * generator is resumed. */
35983         ZEND_VM_INC_OPCODE();
35984 
35985         /* The GOTO VM uses a local opline variable. We need to set the opline
35986          * variable in execute_data so we don't resume at an old position. */
35987         SAVE_OPLINE();
35988 
35989         ZEND_VM_RETURN();
35990 }
35991 
35992 static int ZEND_FASTCALL  ZEND_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35993 {
35994         USE_OPLINE
35995         zend_free_op free_op2;
35996 
35997         SAVE_OPLINE();
35998         pow_function(&EX_T(opline->result.var).tmp_var,
35999                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36000                 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36001 
36002         zval_dtor(free_op2.var);
36003         CHECK_EXCEPTION();
36004         ZEND_VM_NEXT_OPCODE();
36005 }
36006 
36007 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36008 {
36009         return zend_binary_assign_op_helper_SPEC_CV_TMP(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36010 }
36011 
36012 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36013 {
36014         USE_OPLINE
36015         zend_free_op free_op2;
36016 
36017         SAVE_OPLINE();
36018         fast_add_function(&EX_T(opline->result.var).tmp_var,
36019                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36020                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36021 
36022         zval_ptr_dtor_nogc(&free_op2.var);
36023         CHECK_EXCEPTION();
36024         ZEND_VM_NEXT_OPCODE();
36025 }
36026 
36027 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36028 {
36029         USE_OPLINE
36030         zend_free_op free_op2;
36031 
36032         SAVE_OPLINE();
36033         fast_sub_function(&EX_T(opline->result.var).tmp_var,
36034                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36035                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36036 
36037         zval_ptr_dtor_nogc(&free_op2.var);
36038         CHECK_EXCEPTION();
36039         ZEND_VM_NEXT_OPCODE();
36040 }
36041 
36042 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36043 {
36044         USE_OPLINE
36045         zend_free_op free_op2;
36046 
36047         SAVE_OPLINE();
36048         fast_mul_function(&EX_T(opline->result.var).tmp_var,
36049                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36050                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36051 
36052         zval_ptr_dtor_nogc(&free_op2.var);
36053         CHECK_EXCEPTION();
36054         ZEND_VM_NEXT_OPCODE();
36055 }
36056 
36057 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36058 {
36059         USE_OPLINE
36060         zend_free_op free_op2;
36061 
36062         SAVE_OPLINE();
36063         fast_div_function(&EX_T(opline->result.var).tmp_var,
36064                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36065                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36066 
36067         zval_ptr_dtor_nogc(&free_op2.var);
36068         CHECK_EXCEPTION();
36069         ZEND_VM_NEXT_OPCODE();
36070 }
36071 
36072 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36073 {
36074         USE_OPLINE
36075         zend_free_op free_op2;
36076 
36077         SAVE_OPLINE();
36078         fast_mod_function(&EX_T(opline->result.var).tmp_var,
36079                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36080                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36081 
36082         zval_ptr_dtor_nogc(&free_op2.var);
36083         CHECK_EXCEPTION();
36084         ZEND_VM_NEXT_OPCODE();
36085 }
36086 
36087 static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36088 {
36089         USE_OPLINE
36090         zend_free_op free_op2;
36091 
36092         SAVE_OPLINE();
36093         shift_left_function(&EX_T(opline->result.var).tmp_var,
36094                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36095                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36096 
36097         zval_ptr_dtor_nogc(&free_op2.var);
36098         CHECK_EXCEPTION();
36099         ZEND_VM_NEXT_OPCODE();
36100 }
36101 
36102 static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36103 {
36104         USE_OPLINE
36105         zend_free_op free_op2;
36106 
36107         SAVE_OPLINE();
36108         shift_right_function(&EX_T(opline->result.var).tmp_var,
36109                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36110                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36111 
36112         zval_ptr_dtor_nogc(&free_op2.var);
36113         CHECK_EXCEPTION();
36114         ZEND_VM_NEXT_OPCODE();
36115 }
36116 
36117 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36118 {
36119         USE_OPLINE
36120         zend_free_op free_op2;
36121 
36122         SAVE_OPLINE();
36123         concat_function(&EX_T(opline->result.var).tmp_var,
36124                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36125                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36126 
36127         zval_ptr_dtor_nogc(&free_op2.var);
36128         CHECK_EXCEPTION();
36129         ZEND_VM_NEXT_OPCODE();
36130 }
36131 
36132 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36133 {
36134         USE_OPLINE
36135         zend_free_op free_op2;
36136 
36137         SAVE_OPLINE();
36138         is_identical_function(&EX_T(opline->result.var).tmp_var,
36139                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36140                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36141 
36142         zval_ptr_dtor_nogc(&free_op2.var);
36143         CHECK_EXCEPTION();
36144         ZEND_VM_NEXT_OPCODE();
36145 }
36146 
36147 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36148 {
36149         USE_OPLINE
36150         zend_free_op free_op2;
36151         zval *result = &EX_T(opline->result.var).tmp_var;
36152 
36153         SAVE_OPLINE();
36154         is_identical_function(result,
36155                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36156                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36157         Z_LVAL_P(result) = !Z_LVAL_P(result);
36158 
36159         zval_ptr_dtor_nogc(&free_op2.var);
36160         CHECK_EXCEPTION();
36161         ZEND_VM_NEXT_OPCODE();
36162 }
36163 
36164 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36165 {
36166         USE_OPLINE
36167         zend_free_op free_op2;
36168         zval *result = &EX_T(opline->result.var).tmp_var;
36169 
36170         SAVE_OPLINE();
36171         ZVAL_BOOL(result, fast_equal_function(result,
36172                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36173                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
36174 
36175         zval_ptr_dtor_nogc(&free_op2.var);
36176         CHECK_EXCEPTION();
36177         ZEND_VM_NEXT_OPCODE();
36178 }
36179 
36180 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36181 {
36182         USE_OPLINE
36183         zend_free_op free_op2;
36184         zval *result = &EX_T(opline->result.var).tmp_var;
36185 
36186         SAVE_OPLINE();
36187         ZVAL_BOOL(result, fast_not_equal_function(result,
36188                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36189                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
36190 
36191         zval_ptr_dtor_nogc(&free_op2.var);
36192         CHECK_EXCEPTION();
36193         ZEND_VM_NEXT_OPCODE();
36194 }
36195 
36196 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36197 {
36198         USE_OPLINE
36199         zend_free_op free_op2;
36200         zval *result = &EX_T(opline->result.var).tmp_var;
36201 
36202         SAVE_OPLINE();
36203         ZVAL_BOOL(result, fast_is_smaller_function(result,
36204                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36205                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
36206 
36207         zval_ptr_dtor_nogc(&free_op2.var);
36208         CHECK_EXCEPTION();
36209         ZEND_VM_NEXT_OPCODE();
36210 }
36211 
36212 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36213 {
36214         USE_OPLINE
36215         zend_free_op free_op2;
36216         zval *result = &EX_T(opline->result.var).tmp_var;
36217 
36218         SAVE_OPLINE();
36219         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
36220                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36221                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
36222 
36223         zval_ptr_dtor_nogc(&free_op2.var);
36224         CHECK_EXCEPTION();
36225         ZEND_VM_NEXT_OPCODE();
36226 }
36227 
36228 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36229 {
36230         USE_OPLINE
36231         zend_free_op free_op2;
36232 
36233         SAVE_OPLINE();
36234         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
36235                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36236                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36237 
36238         zval_ptr_dtor_nogc(&free_op2.var);
36239         CHECK_EXCEPTION();
36240         ZEND_VM_NEXT_OPCODE();
36241 }
36242 
36243 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36244 {
36245         USE_OPLINE
36246         zend_free_op free_op2;
36247 
36248         SAVE_OPLINE();
36249         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
36250                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36251                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36252 
36253         zval_ptr_dtor_nogc(&free_op2.var);
36254         CHECK_EXCEPTION();
36255         ZEND_VM_NEXT_OPCODE();
36256 }
36257 
36258 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36259 {
36260         USE_OPLINE
36261         zend_free_op free_op2;
36262 
36263         SAVE_OPLINE();
36264         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
36265                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36266                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36267 
36268         zval_ptr_dtor_nogc(&free_op2.var);
36269         CHECK_EXCEPTION();
36270         ZEND_VM_NEXT_OPCODE();
36271 }
36272 
36273 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36274 {
36275         USE_OPLINE
36276         zend_free_op free_op2;
36277 
36278         SAVE_OPLINE();
36279         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
36280                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
36281                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
36282 
36283         zval_ptr_dtor_nogc(&free_op2.var);
36284         CHECK_EXCEPTION();
36285         ZEND_VM_NEXT_OPCODE();
36286 }
36287 
36288 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
36289 {
36290         USE_OPLINE
36291         zend_free_op free_op2, free_op_data1;
36292         zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36293         zval *object;
36294         zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36295         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
36296         int have_get_ptr = 0;
36297 
36298         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
36299                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
36300         }
36301 
36302         make_real_object(object_ptr TSRMLS_CC);
36303         object = *object_ptr;
36304 
36305         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36306                 zend_error(E_WARNING, "Attempt to assign property of non-object");
36307                 zval_ptr_dtor_nogc(&free_op2.var);
36308                 FREE_OP(free_op_data1);
36309 
36310                 if (RETURN_VALUE_USED(opline)) {
36311                         PZVAL_LOCK(&EG(uninitialized_zval));
36312                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
36313                 }
36314         } else {
36315                 /* here we are sure we are dealing with an object */
36316                 if (0) {
36317                         MAKE_REAL_ZVAL_PTR(property);
36318                 }
36319 
36320                 /* here property is a string */
36321                 if (opline->extended_value == ZEND_ASSIGN_OBJ
36322                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
36323                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36324                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
36325                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
36326 
36327                                 have_get_ptr = 1;
36328                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
36329                                 if (RETURN_VALUE_USED(opline)) {
36330                                         PZVAL_LOCK(*zptr);
36331                                         EX_T(opline->result.var).var.ptr = *zptr;
36332                                 }
36333                         }
36334                 }
36335 
36336                 if (!have_get_ptr) {
36337                         zval *z = NULL;
36338 
36339                         Z_ADDREF_P(object);
36340                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
36341                                 if (Z_OBJ_HT_P(object)->read_property) {
36342                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36343                                 }
36344                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
36345                                 if (Z_OBJ_HT_P(object)->read_dimension) {
36346                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
36347                                 }
36348                         }
36349                         if (z) {
36350                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
36351                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
36352 
36353                                         if (Z_REFCOUNT_P(z) == 0) {
36354                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
36355                                                 zval_dtor(z);
36356                                                 FREE_ZVAL(z);
36357                                         }
36358                                         z = value;
36359                                 }
36360                                 Z_ADDREF_P(z);
36361                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
36362                                 binary_op(z, z, value TSRMLS_CC);
36363                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
36364                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36365                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
36366                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
36367                                 }
36368                                 if (RETURN_VALUE_USED(opline)) {
36369                                         PZVAL_LOCK(z);
36370                                         EX_T(opline->result.var).var.ptr = z;
36371                                 }
36372                                 zval_ptr_dtor(&z);
36373                         } else {
36374                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
36375                                 if (RETURN_VALUE_USED(opline)) {
36376                                         PZVAL_LOCK(&EG(uninitialized_zval));
36377                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
36378                                 }
36379                         }
36380                         zval_ptr_dtor(&object);
36381                 }
36382 
36383                 if (0) {
36384                         zval_ptr_dtor(&property);
36385                 } else {
36386                         zval_ptr_dtor_nogc(&free_op2.var);
36387                 }
36388                 FREE_OP(free_op_data1);
36389         }
36390 
36391         /* assign_obj has two opcodes! */
36392         CHECK_EXCEPTION();
36393         ZEND_VM_INC_OPCODE();
36394         ZEND_VM_NEXT_OPCODE();
36395 }
36396 
36397 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
36398 {
36399         USE_OPLINE
36400         zend_free_op free_op2, free_op_data2, free_op_data1;
36401         zval **var_ptr;
36402         zval *value;
36403 
36404         SAVE_OPLINE();
36405         switch (opline->extended_value) {
36406                 case ZEND_ASSIGN_OBJ:
36407                         return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36408                         break;
36409                 case ZEND_ASSIGN_DIM: {
36410                                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36411 
36412                                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
36413                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
36414                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
36415                                         if (IS_CV == IS_VAR && !0) {
36416                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
36417                                         }
36418                                         return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36419                                 } else {
36420                                         zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36421 
36422                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
36423                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
36424                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
36425                                 }
36426                         }
36427                         break;
36428                 default:
36429                         value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36430                         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36431                         /* do nothing */
36432                         break;
36433         }
36434 
36435         if (UNEXPECTED(var_ptr == NULL)) {
36436                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
36437         }
36438 
36439         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
36440                 if (RETURN_VALUE_USED(opline)) {
36441                         PZVAL_LOCK(&EG(uninitialized_zval));
36442                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
36443                 }
36444                 zval_ptr_dtor_nogc(&free_op2.var);
36445 
36446                 CHECK_EXCEPTION();
36447                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
36448                         ZEND_VM_INC_OPCODE();
36449                 }
36450                 ZEND_VM_NEXT_OPCODE();
36451         }
36452 
36453         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
36454 
36455         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
36456            && Z_OBJ_HANDLER_PP(var_ptr, get)
36457            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
36458                 /* proxy object */
36459                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
36460                 Z_ADDREF_P(objval);
36461                 binary_op(objval, objval, value TSRMLS_CC);
36462                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
36463                 zval_ptr_dtor(&objval);
36464         } else {
36465                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
36466         }
36467 
36468         if (RETURN_VALUE_USED(opline)) {
36469                 PZVAL_LOCK(*var_ptr);
36470                 EX_T(opline->result.var).var.ptr = *var_ptr;
36471         }
36472         zval_ptr_dtor_nogc(&free_op2.var);
36473 
36474         if (opline->extended_value == ZEND_ASSIGN_DIM) {
36475                 FREE_OP(free_op_data1);
36476                 FREE_OP_VAR_PTR(free_op_data2);
36477 
36478                 CHECK_EXCEPTION();
36479                 ZEND_VM_INC_OPCODE();
36480         } else {
36481 
36482                 CHECK_EXCEPTION();
36483         }
36484         ZEND_VM_NEXT_OPCODE();
36485 }
36486 
36487 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36488 {
36489         return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36490 }
36491 
36492 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36493 {
36494         return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36495 }
36496 
36497 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36498 {
36499         return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36500 }
36501 
36502 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36503 {
36504         return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36505 }
36506 
36507 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36508 {
36509         return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36510 }
36511 
36512 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36513 {
36514         return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36515 }
36516 
36517 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36518 {
36519         return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36520 }
36521 
36522 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36523 {
36524         return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36525 }
36526 
36527 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36528 {
36529         return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36530 }
36531 
36532 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36533 {
36534         return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36535 }
36536 
36537 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36538 {
36539         return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36540 }
36541 
36542 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
36543 {
36544         USE_OPLINE
36545         zend_free_op free_op2;
36546         zval **object_ptr;
36547         zval *object;
36548         zval *property;
36549         zval **retval;
36550         int have_get_ptr = 0;
36551 
36552         SAVE_OPLINE();
36553         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36554         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36555         retval = &EX_T(opline->result.var).var.ptr;
36556 
36557         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
36558                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
36559         }
36560 
36561         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
36562         object = *object_ptr;
36563 
36564         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36565                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
36566                 zval_ptr_dtor_nogc(&free_op2.var);
36567                 if (RETURN_VALUE_USED(opline)) {
36568                         PZVAL_LOCK(&EG(uninitialized_zval));
36569                         *retval = &EG(uninitialized_zval);
36570                 }
36571 
36572                 CHECK_EXCEPTION();
36573                 ZEND_VM_NEXT_OPCODE();
36574         }
36575 
36576         /* here we are sure we are dealing with an object */
36577 
36578         if (0) {
36579                 MAKE_REAL_ZVAL_PTR(property);
36580         }
36581 
36582         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
36583                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36584                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
36585                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
36586 
36587                         have_get_ptr = 1;
36588                         incdec_op(*zptr);
36589                         if (RETURN_VALUE_USED(opline)) {
36590                                 *retval = *zptr;
36591                                 PZVAL_LOCK(*retval);
36592                         }
36593                 }
36594         }
36595 
36596         if (!have_get_ptr) {
36597                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
36598                         zval *z;
36599 
36600                         Z_ADDREF_P(object);
36601                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36602 
36603                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
36604                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
36605 
36606                                 if (Z_REFCOUNT_P(z) == 0) {
36607                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
36608                                         zval_dtor(z);
36609                                         FREE_ZVAL(z);
36610                                 }
36611                                 z = value;
36612                         }
36613                         Z_ADDREF_P(z);
36614                         SEPARATE_ZVAL_IF_NOT_REF(&z);
36615                         incdec_op(z);
36616                         *retval = z;
36617                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36618                         zval_ptr_dtor(&object);
36619                         SELECTIVE_PZVAL_LOCK(*retval, opline);
36620                         zval_ptr_dtor(&z);
36621                 } else {
36622                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
36623                         if (RETURN_VALUE_USED(opline)) {
36624                                 PZVAL_LOCK(&EG(uninitialized_zval));
36625                                 *retval = &EG(uninitialized_zval);
36626                         }
36627                 }
36628         }
36629 
36630         if (0) {
36631                 zval_ptr_dtor(&property);
36632         } else {
36633                 zval_ptr_dtor_nogc(&free_op2.var);
36634         }
36635 
36636         CHECK_EXCEPTION();
36637         ZEND_VM_NEXT_OPCODE();
36638 }
36639 
36640 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36641 {
36642         return zend_pre_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36643 }
36644 
36645 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36646 {
36647         return zend_pre_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36648 }
36649 
36650 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
36651 {
36652         USE_OPLINE
36653         zend_free_op free_op2;
36654         zval **object_ptr;
36655         zval *object;
36656         zval *property;
36657         zval *retval;
36658         int have_get_ptr = 0;
36659 
36660         SAVE_OPLINE();
36661         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36662         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
36663         retval = &EX_T(opline->result.var).tmp_var;
36664 
36665         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
36666                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
36667         }
36668 
36669         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
36670         object = *object_ptr;
36671 
36672         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36673                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
36674                 zval_ptr_dtor_nogc(&free_op2.var);
36675                 ZVAL_NULL(retval);
36676 
36677                 CHECK_EXCEPTION();
36678                 ZEND_VM_NEXT_OPCODE();
36679         }
36680 
36681         /* here we are sure we are dealing with an object */
36682 
36683         if (0) {
36684                 MAKE_REAL_ZVAL_PTR(property);
36685         }
36686 
36687         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
36688                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36689                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
36690                         have_get_ptr = 1;
36691                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
36692 
36693                         ZVAL_COPY_VALUE(retval, *zptr);
36694                         zendi_zval_copy_ctor(*retval);
36695 
36696                         incdec_op(*zptr);
36697 
36698                 }
36699         }
36700 
36701         if (!have_get_ptr) {
36702                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
36703                         zval *z, *z_copy;
36704 
36705                         Z_ADDREF_P(object);
36706                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36707                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
36708                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
36709 
36710                                 if (Z_REFCOUNT_P(z) == 0) {
36711                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
36712                                         zval_dtor(z);
36713                                         FREE_ZVAL(z);
36714                                 }
36715                                 z = value;
36716                         }
36717                         ZVAL_COPY_VALUE(retval, z);
36718                         zendi_zval_copy_ctor(*retval);
36719                         ALLOC_ZVAL(z_copy);
36720                         INIT_PZVAL_COPY(z_copy, z);
36721                         zendi_zval_copy_ctor(*z_copy);
36722                         incdec_op(z_copy);
36723                         Z_ADDREF_P(z);
36724                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
36725                         zval_ptr_dtor(&object);
36726                         zval_ptr_dtor(&z_copy);
36727                         zval_ptr_dtor(&z);
36728                 } else {
36729                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
36730                         ZVAL_NULL(retval);
36731                 }
36732         }
36733 
36734         if (0) {
36735                 zval_ptr_dtor(&property);
36736         } else {
36737                 zval_ptr_dtor_nogc(&free_op2.var);
36738         }
36739 
36740         CHECK_EXCEPTION();
36741         ZEND_VM_NEXT_OPCODE();
36742 }
36743 
36744 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36745 {
36746         return zend_post_incdec_property_helper_SPEC_CV_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36747 }
36748 
36749 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36750 {
36751         return zend_post_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36752 }
36753 
36754 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
36755 {
36756         USE_OPLINE
36757         zend_free_op free_op1;
36758         zval *varname;
36759         zval **retval;
36760         zval tmp_varname;
36761         HashTable *target_symbol_table;
36762         ulong hash_value;
36763 
36764         SAVE_OPLINE();
36765         varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
36766 
36767         if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
36768                 ZVAL_COPY_VALUE(&tmp_varname, varname);
36769                 zval_copy_ctor(&tmp_varname);
36770                 Z_SET_REFCOUNT(tmp_varname, 1);
36771                 Z_UNSET_ISREF(tmp_varname);
36772                 convert_to_string(&tmp_varname);
36773                 varname = &tmp_varname;
36774         }
36775 
36776         if (IS_VAR != IS_UNUSED) {
36777                 zend_class_entry *ce;
36778 
36779                 if (IS_VAR == IS_CONST) {
36780                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
36781                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
36782                         } else {
36783                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
36784                                 if (UNEXPECTED(ce == NULL)) {
36785                                         if (IS_CV != IS_CONST && varname == &tmp_varname) {
36786                                                 zval_dtor(&tmp_varname);
36787                                         }
36788 
36789                                         CHECK_EXCEPTION();
36790                                         ZEND_VM_NEXT_OPCODE();
36791                                 }
36792                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
36793                         }
36794                 } else {
36795                         ce = EX_T(opline->op2.var).class_entry;
36796                 }
36797                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
36798 
36799         } else {
36800                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
36801 /*
36802                 if (!target_symbol_table) {
36803                         CHECK_EXCEPTION();
36804                         ZEND_VM_NEXT_OPCODE();
36805                 }
36806 */
36807                 if (IS_CV == IS_CONST) {
36808                         hash_value = Z_HASH_P(varname);
36809                 } else {
36810                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
36811                 }
36812 
36813                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
36814                         switch (type) {
36815                                 case BP_VAR_R:
36816                                 case BP_VAR_UNSET:
36817                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
36818                                         /* break missing intentionally */
36819                                 case BP_VAR_IS:
36820                                         retval = &EG(uninitialized_zval_ptr);
36821                                         break;
36822                                 case BP_VAR_RW:
36823                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
36824                                         /* break missing intentionally */
36825                                 case BP_VAR_W:
36826                                         Z_ADDREF_P(&EG(uninitialized_zval));
36827                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
36828                                         break;
36829                                 EMPTY_SWITCH_DEFAULT_CASE()
36830                         }
36831                 }
36832                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
36833                         case ZEND_FETCH_GLOBAL:
36834                                 if (IS_CV != IS_TMP_VAR) {
36835 
36836                                 }
36837                                 break;
36838                         case ZEND_FETCH_LOCAL:
36839 
36840                                 break;
36841                         case ZEND_FETCH_STATIC:
36842                                 zval_update_constant(retval, 1 TSRMLS_CC);
36843                                 break;
36844                         case ZEND_FETCH_GLOBAL_LOCK:
36845                                 if (IS_CV == IS_VAR && !free_op1.var) {
36846                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
36847                                 }
36848                                 break;
36849                 }
36850         }
36851 
36852 
36853         if (IS_CV != IS_CONST && varname == &tmp_varname) {
36854                 zval_dtor(&tmp_varname);
36855         }
36856         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
36857                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
36858         }
36859         PZVAL_LOCK(*retval);
36860         switch (type) {
36861                 case BP_VAR_R:
36862                 case BP_VAR_IS:
36863                         EX_T(opline->result.var).var.ptr = *retval;
36864                         break;
36865                 case BP_VAR_UNSET: {
36866                         zend_free_op free_res;
36867 
36868                         PZVAL_UNLOCK(*retval, &free_res);
36869                         if (retval != &EG(uninitialized_zval_ptr)) {
36870                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
36871                         }
36872                         PZVAL_LOCK(*retval);
36873                         FREE_OP_VAR_PTR(free_res);
36874                 }
36875                 /* break missing intentionally */
36876                 default:
36877                         EX_T(opline->result.var).var.ptr_ptr = retval;
36878                         break;
36879         }
36880         CHECK_EXCEPTION();
36881         ZEND_VM_NEXT_OPCODE();
36882 }
36883 
36884 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36885 {
36886         return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36887 }
36888 
36889 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36890 {
36891         return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36892 }
36893 
36894 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36895 {
36896         return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36897 }
36898 
36899 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36900 {
36901         USE_OPLINE
36902 
36903         return zend_fetch_var_address_helper_SPEC_CV_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36904 }
36905 
36906 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36907 {
36908         return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36909 }
36910 
36911 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36912 {
36913         return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
36914 }
36915 
36916 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36917 {
36918         USE_OPLINE
36919         zend_free_op free_op2;
36920         zval *container;
36921 
36922         SAVE_OPLINE();
36923         container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
36924         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
36925         zval_ptr_dtor_nogc(&free_op2.var);
36926         if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
36927 
36928         }
36929         CHECK_EXCEPTION();
36930         ZEND_VM_NEXT_OPCODE();
36931 }
36932 
36933 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36934 {
36935         USE_OPLINE
36936         zend_free_op free_op1, free_op2;
36937         zval **container;
36938 
36939         SAVE_OPLINE();
36940         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
36941 
36942         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
36943                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
36944         }
36945         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
36946         zval_ptr_dtor_nogc(&free_op2.var);
36947         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
36948                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
36949         }
36950 
36951         /* We are going to assign the result by reference */
36952         if (UNEXPECTED(opline->extended_value != 0)) {
36953                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
36954 
36955                 if (retval_ptr) {
36956                         Z_DELREF_PP(retval_ptr);
36957                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
36958                         Z_ADDREF_PP(retval_ptr);
36959                 }
36960         }
36961 
36962         CHECK_EXCEPTION();
36963         ZEND_VM_NEXT_OPCODE();
36964 }
36965 
36966 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36967 {
36968         USE_OPLINE
36969         zend_free_op free_op1, free_op2;
36970         zval **container;
36971 
36972         SAVE_OPLINE();
36973         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
36974 
36975         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
36976                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
36977         }
36978         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
36979         zval_ptr_dtor_nogc(&free_op2.var);
36980         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
36981                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
36982         }
36983 
36984         CHECK_EXCEPTION();
36985         ZEND_VM_NEXT_OPCODE();
36986 }
36987 
36988 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36989 {
36990         USE_OPLINE
36991         zend_free_op free_op2;
36992         zval *container;
36993 
36994         SAVE_OPLINE();
36995         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
36996         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC);
36997         zval_ptr_dtor_nogc(&free_op2.var);
36998 
36999         CHECK_EXCEPTION();
37000         ZEND_VM_NEXT_OPCODE();
37001 }
37002 
37003 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37004 {
37005         USE_OPLINE
37006         zend_free_op free_op1, free_op2;
37007 
37008         SAVE_OPLINE();
37009 
37010         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
37011                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37012                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37013                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37014                 }
37015                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
37016                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37017                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37018                 }
37019                 zval_ptr_dtor_nogc(&free_op2.var);
37020 
37021         } else {
37022                 zval *container;
37023 
37024                 if (IS_VAR == IS_UNUSED) {
37025                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
37026                 }
37027                 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37028                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
37029                 zval_ptr_dtor_nogc(&free_op2.var);
37030 
37031         }
37032         CHECK_EXCEPTION();
37033         ZEND_VM_NEXT_OPCODE();
37034 }
37035 
37036 static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37037 {
37038         USE_OPLINE
37039         zend_free_op free_op1, free_op2;
37040         zval **container;
37041 
37042         SAVE_OPLINE();
37043         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
37044 
37045         if (IS_CV == IS_CV) {
37046                 if (container != &EG(uninitialized_zval_ptr)) {
37047                         SEPARATE_ZVAL_IF_NOT_REF(container);
37048                 }
37049         }
37050         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37051                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37052         }
37053         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC);
37054         zval_ptr_dtor_nogc(&free_op2.var);
37055         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37056                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37057         }
37058 
37059         if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
37060                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
37061                 ZEND_VM_NEXT_OPCODE();
37062         } else {
37063                 zend_free_op free_res;
37064                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
37065 
37066                 PZVAL_UNLOCK(*retval_ptr, &free_res);
37067                 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
37068                         SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
37069                 }
37070                 PZVAL_LOCK(*retval_ptr);
37071                 FREE_OP_VAR_PTR(free_res);
37072                 CHECK_EXCEPTION();
37073                 ZEND_VM_NEXT_OPCODE();
37074         }
37075 }
37076 
37077 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS)
37078 {
37079         USE_OPLINE
37080 
37081         zval *container;
37082         zend_free_op free_op2;
37083         zval *offset;
37084 
37085         SAVE_OPLINE();
37086         container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37087         offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37088 
37089         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
37090             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
37091                 zend_error(E_NOTICE, "Trying to get property of non-object");
37092                 PZVAL_LOCK(&EG(uninitialized_zval));
37093                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37094                 zval_ptr_dtor_nogc(&free_op2.var);
37095         } else {
37096                 zval *retval;
37097 
37098                 if (0) {
37099                         MAKE_REAL_ZVAL_PTR(offset);
37100                 }
37101 
37102                 /* here we are sure we are dealing with an object */
37103                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37104 
37105                 PZVAL_LOCK(retval);
37106                 EX_T(opline->result.var).var.ptr = retval;
37107 
37108                 if (0) {
37109                         zval_ptr_dtor(&offset);
37110                 } else {
37111                         zval_ptr_dtor_nogc(&free_op2.var);
37112                 }
37113         }
37114 
37115         CHECK_EXCEPTION();
37116         ZEND_VM_NEXT_OPCODE();
37117 }
37118 
37119 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37120 {
37121         return zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37122 }
37123 
37124 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37125 {
37126         USE_OPLINE
37127         zend_free_op free_op1, free_op2;
37128         zval *property;
37129         zval **container;
37130 
37131         SAVE_OPLINE();
37132         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37133 
37134         if (0) {
37135                 MAKE_REAL_ZVAL_PTR(property);
37136         }
37137         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37138         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37139                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
37140         }
37141 
37142         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
37143         if (0) {
37144                 zval_ptr_dtor(&property);
37145         } else {
37146                 zval_ptr_dtor_nogc(&free_op2.var);
37147         }
37148         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37149                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37150         }
37151 
37152         /* We are going to assign the result by reference */
37153         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
37154                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
37155 
37156                 Z_DELREF_PP(retval_ptr);
37157                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
37158                 Z_ADDREF_PP(retval_ptr);
37159                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
37160                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
37161         }
37162 
37163         CHECK_EXCEPTION();
37164         ZEND_VM_NEXT_OPCODE();
37165 }
37166 
37167 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37168 {
37169         USE_OPLINE
37170         zend_free_op free_op1, free_op2;
37171         zval *property;
37172         zval **container;
37173 
37174         SAVE_OPLINE();
37175         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37176         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
37177 
37178         if (0) {
37179                 MAKE_REAL_ZVAL_PTR(property);
37180         }
37181         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37182                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
37183         }
37184         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
37185         if (0) {
37186                 zval_ptr_dtor(&property);
37187         } else {
37188                 zval_ptr_dtor_nogc(&free_op2.var);
37189         }
37190         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37191                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37192         }
37193 
37194         CHECK_EXCEPTION();
37195         ZEND_VM_NEXT_OPCODE();
37196 }
37197 
37198 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37199 {
37200         USE_OPLINE
37201 
37202         zval *container;
37203         zend_free_op free_op2;
37204         zval *offset;
37205 
37206         SAVE_OPLINE();
37207         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
37208         offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37209 
37210         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
37211             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
37212                 PZVAL_LOCK(&EG(uninitialized_zval));
37213                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37214                 zval_ptr_dtor_nogc(&free_op2.var);
37215         } else {
37216                 zval *retval;
37217 
37218                 if (0) {
37219                         MAKE_REAL_ZVAL_PTR(offset);
37220                 }
37221 
37222                 /* here we are sure we are dealing with an object */
37223                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37224 
37225                 PZVAL_LOCK(retval);
37226                 EX_T(opline->result.var).var.ptr = retval;
37227 
37228                 if (0) {
37229                         zval_ptr_dtor(&offset);
37230                 } else {
37231                         zval_ptr_dtor_nogc(&free_op2.var);
37232                 }
37233         }
37234 
37235         CHECK_EXCEPTION();
37236         ZEND_VM_NEXT_OPCODE();
37237 }
37238 
37239 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37240 {
37241         USE_OPLINE
37242 
37243         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
37244                 /* Behave like FETCH_OBJ_W */
37245                 zend_free_op free_op1, free_op2;
37246                 zval *property;
37247                 zval **container;
37248 
37249                 SAVE_OPLINE();
37250                 property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37251                 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37252 
37253                 if (0) {
37254                         MAKE_REAL_ZVAL_PTR(property);
37255                 }
37256                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37257                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
37258                 }
37259                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
37260                 if (0) {
37261                         zval_ptr_dtor(&property);
37262                 } else {
37263                         zval_ptr_dtor_nogc(&free_op2.var);
37264                 }
37265                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37266                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37267                 }
37268 
37269                 CHECK_EXCEPTION();
37270                 ZEND_VM_NEXT_OPCODE();
37271         } else {
37272                 return zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37273         }
37274 }
37275 
37276 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37277 {
37278         USE_OPLINE
37279         zend_free_op free_op1, free_op2, free_res;
37280         zval **container;
37281         zval *property;
37282 
37283         SAVE_OPLINE();
37284         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
37285         property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37286 
37287         if (IS_CV == IS_CV) {
37288                 if (container != &EG(uninitialized_zval_ptr)) {
37289                         SEPARATE_ZVAL_IF_NOT_REF(container);
37290                 }
37291         }
37292         if (0) {
37293                 MAKE_REAL_ZVAL_PTR(property);
37294         }
37295         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
37296                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
37297         }
37298         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
37299         if (0) {
37300                 zval_ptr_dtor(&property);
37301         } else {
37302                 zval_ptr_dtor_nogc(&free_op2.var);
37303         }
37304         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
37305                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
37306         }
37307 
37308         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
37309         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
37310                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
37311         }
37312         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
37313         FREE_OP_VAR_PTR(free_res);
37314         CHECK_EXCEPTION();
37315         ZEND_VM_NEXT_OPCODE();
37316 }
37317 
37318 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37319 {
37320         USE_OPLINE
37321         zend_free_op free_op2;
37322         zval **object_ptr;
37323         zval *property_name;
37324 
37325         SAVE_OPLINE();
37326         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37327         property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37328 
37329         if (0) {
37330                 MAKE_REAL_ZVAL_PTR(property_name);
37331         }
37332         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
37333                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37334         }
37335         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37336         if (0) {
37337                 zval_ptr_dtor(&property_name);
37338         } else {
37339                 zval_ptr_dtor_nogc(&free_op2.var);
37340         }
37341 
37342         /* assign_obj has two opcodes! */
37343         CHECK_EXCEPTION();
37344         ZEND_VM_INC_OPCODE();
37345         ZEND_VM_NEXT_OPCODE();
37346 }
37347 
37348 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37349 {
37350         USE_OPLINE
37351 
37352         zval **object_ptr;
37353 
37354         SAVE_OPLINE();
37355         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37356 
37357         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
37358                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
37359         }
37360         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
37361                 zend_free_op free_op2;
37362                 zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37363 
37364                 if (0) {
37365                         MAKE_REAL_ZVAL_PTR(property_name);
37366                 }
37367                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37368                 if (0) {
37369                         zval_ptr_dtor(&property_name);
37370                 } else {
37371                         zval_ptr_dtor_nogc(&free_op2.var);
37372                 }
37373         } else {
37374                 zend_free_op free_op2, free_op_data1, free_op_data2;
37375                 zval *value;
37376                 zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37377                 zval **variable_ptr_ptr;
37378 
37379                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC);
37380                 zval_ptr_dtor_nogc(&free_op2.var);
37381 
37382                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
37383                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
37384                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
37385                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
37386                                 if (RETURN_VALUE_USED(opline)) {
37387                                         zval *retval;
37388 
37389                                         ALLOC_ZVAL(retval);
37390                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
37391                                         INIT_PZVAL(retval);
37392                                         EX_T(opline->result.var).var.ptr = retval;
37393                                 }
37394                         } else if (RETURN_VALUE_USED(opline)) {
37395                                 PZVAL_LOCK(&EG(uninitialized_zval));
37396                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37397                         }
37398                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
37399                         if (IS_TMP_FREE(free_op_data1)) {
37400                                 zval_dtor(value);
37401                         }
37402                         if (RETURN_VALUE_USED(opline)) {
37403                                 PZVAL_LOCK(&EG(uninitialized_zval));
37404                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37405                         }
37406                 } else {
37407                         if ((opline+1)->op1_type == IS_TMP_VAR) {
37408                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37409                         } else if ((opline+1)->op1_type == IS_CONST) {
37410                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37411                         } else {
37412                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37413                         }
37414                         if (RETURN_VALUE_USED(opline)) {
37415                                 PZVAL_LOCK(value);
37416                                 EX_T(opline->result.var).var.ptr = value;
37417                         }
37418                 }
37419                 FREE_OP_VAR_PTR(free_op_data2);
37420                 FREE_OP_IF_VAR(free_op_data1);
37421         }
37422 
37423         /* assign_dim has two opcodes! */
37424         CHECK_EXCEPTION();
37425         ZEND_VM_INC_OPCODE();
37426         ZEND_VM_NEXT_OPCODE();
37427 }
37428 
37429 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37430 {
37431         USE_OPLINE
37432         zend_free_op free_op2;
37433         zval *value;
37434         zval **variable_ptr_ptr;
37435 
37436         SAVE_OPLINE();
37437         value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37438         variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37439 
37440         if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
37441                 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) {
37442                         if (RETURN_VALUE_USED(opline)) {
37443                                 zval *retval;
37444 
37445                                 ALLOC_ZVAL(retval);
37446                                 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
37447                                 INIT_PZVAL(retval);
37448                                 EX_T(opline->result.var).var.ptr = retval;
37449                         }
37450                 } else if (RETURN_VALUE_USED(opline)) {
37451                         PZVAL_LOCK(&EG(uninitialized_zval));
37452                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37453                 }
37454         } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
37455                 if (0) {
37456                         zval_dtor(value);
37457                 }
37458                 if (RETURN_VALUE_USED(opline)) {
37459                         PZVAL_LOCK(&EG(uninitialized_zval));
37460                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
37461                 }
37462         } else {
37463                 if (IS_VAR == IS_TMP_VAR) {
37464                         value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37465                 } else if (IS_VAR == IS_CONST) {
37466                         value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37467                 } else {
37468                         value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
37469                 }
37470                 if (RETURN_VALUE_USED(opline)) {
37471                         PZVAL_LOCK(value);
37472                         EX_T(opline->result.var).var.ptr = value;
37473                 }
37474         }
37475 
37476         if (IS_CV == IS_VAR && 0) {
37477                 zval_ptr_dtor_nogc(&value);
37478         }
37479 
37480         /* zend_assign_to_variable() always takes care of op2, never free it! */
37481         zval_ptr_dtor_nogc(&free_op2.var);
37482 
37483         CHECK_EXCEPTION();
37484         ZEND_VM_NEXT_OPCODE();
37485 }
37486 
37487 static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37488 {
37489         USE_OPLINE
37490         zend_free_op free_op2;
37491         zval **variable_ptr_ptr;
37492         zval **value_ptr_ptr;
37493 
37494         SAVE_OPLINE();
37495         value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37496 
37497         if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
37498                 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
37499         }
37500 
37501         if (IS_VAR == IS_VAR &&
37502             value_ptr_ptr &&
37503             !Z_ISREF_PP(value_ptr_ptr) &&
37504             opline->extended_value == ZEND_RETURNS_FUNCTION &&
37505             !EX_T(opline->op2.var).var.fcall_returned_reference) {
37506                 if (free_op2.var == NULL) {
37507                         PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
37508                 }
37509                 zend_error(E_STRICT, "Only variables should be assigned by reference");
37510                 if (UNEXPECTED(EG(exception) != NULL)) {
37511                         if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
37512                         HANDLE_EXCEPTION();
37513                 }
37514                 return ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37515         } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
37516                 PZVAL_LOCK(*value_ptr_ptr);
37517         }
37518 
37519         variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37520         if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
37521             (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
37522                 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
37523         }
37524         zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
37525 
37526         if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
37527                 Z_DELREF_PP(variable_ptr_ptr);
37528         }
37529 
37530         if (RETURN_VALUE_USED(opline)) {
37531                 PZVAL_LOCK(*variable_ptr_ptr);
37532                 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
37533         }
37534 
37535         if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
37536 
37537         CHECK_EXCEPTION();
37538         ZEND_VM_NEXT_OPCODE();
37539 }
37540 
37541 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37542 {
37543         USE_OPLINE
37544         zval *function_name;
37545         char *function_name_strval;
37546         int function_name_strlen;
37547         zend_free_op free_op2;
37548         call_slot *call = EX(call_slots) + opline->result.num;
37549 
37550         SAVE_OPLINE();
37551 
37552         function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37553 
37554         if (IS_VAR != IS_CONST &&
37555             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37556                 if (UNEXPECTED(EG(exception) != NULL)) {
37557                         HANDLE_EXCEPTION();
37558                 }
37559                 zend_error_noreturn(E_ERROR, "Method name must be a string");
37560         }
37561 
37562         function_name_strval = Z_STRVAL_P(function_name);
37563         function_name_strlen = Z_STRLEN_P(function_name);
37564 
37565         call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37566 
37567         if (EXPECTED(call->object != NULL) &&
37568             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
37569                 call->called_scope = Z_OBJCE_P(call->object);
37570 
37571                 if (IS_VAR != IS_CONST ||
37572                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
37573                     zval *object = call->object;
37574 
37575                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
37576                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
37577                         }
37578 
37579                         /* First, locate the function. */
37580                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
37581                         if (UNEXPECTED(call->fbc == NULL)) {
37582                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
37583                         }
37584                         if (IS_VAR == IS_CONST &&
37585                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
37586                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
37587                             EXPECTED(call->object == object)) {
37588                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
37589                         }
37590                 }
37591         } else {
37592                 if (UNEXPECTED(EG(exception) != NULL)) {
37593                         zval_ptr_dtor_nogc(&free_op2.var);
37594                         HANDLE_EXCEPTION();
37595                 }
37596                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
37597         }
37598 
37599         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
37600                 call->object = NULL;
37601         } else {
37602                 if (!PZVAL_IS_REF(call->object)) {
37603                         Z_ADDREF_P(call->object); /* For $this pointer */
37604                 } else {
37605                         zval *this_ptr;
37606                         ALLOC_ZVAL(this_ptr);
37607                         INIT_PZVAL_COPY(this_ptr, call->object);
37608                         zval_copy_ctor(this_ptr);
37609                         call->object = this_ptr;
37610                 }
37611         }
37612 
37613         call->num_additional_args = 0;
37614         call->is_ctor_call = 0;
37615         EX(call) = call;
37616 
37617         zval_ptr_dtor_nogc(&free_op2.var);
37618 
37619         CHECK_EXCEPTION();
37620         ZEND_VM_NEXT_OPCODE();
37621 }
37622 
37623 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37624 {
37625         USE_OPLINE
37626         zend_free_op free_op2;
37627 
37628         SAVE_OPLINE();
37629         is_equal_function(&EX_T(opline->result.var).tmp_var,
37630                                  _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
37631                                  _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
37632 
37633         zval_ptr_dtor_nogc(&free_op2.var);
37634         CHECK_EXCEPTION();
37635         ZEND_VM_NEXT_OPCODE();
37636 }
37637 
37638 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37639 {
37640         USE_OPLINE
37641 
37642         zval *expr_ptr;
37643 
37644         SAVE_OPLINE();
37645         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
37646                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
37647 
37648                 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
37649                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
37650                 }
37651                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
37652                 expr_ptr = *expr_ptr_ptr;
37653                 Z_ADDREF_P(expr_ptr);
37654         } else {
37655                 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37656                 if (0) { /* temporary variable */
37657                         zval *new_expr;
37658 
37659                         ALLOC_ZVAL(new_expr);
37660                         INIT_PZVAL_COPY(new_expr, expr_ptr);
37661                         expr_ptr = new_expr;
37662                 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
37663                         zval *new_expr;
37664 
37665                         ALLOC_ZVAL(new_expr);
37666                         INIT_PZVAL_COPY(new_expr, expr_ptr);
37667                         expr_ptr = new_expr;
37668                         zendi_zval_copy_ctor(*expr_ptr);
37669 
37670                 } else if (IS_CV == IS_CV) {
37671                         Z_ADDREF_P(expr_ptr);
37672                 }
37673         }
37674 
37675         if (IS_VAR != IS_UNUSED) {
37676                 zend_free_op free_op2;
37677                 zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37678                 ulong hval;
37679 
37680                 switch (Z_TYPE_P(offset)) {
37681                         case IS_DOUBLE:
37682                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
37683                                 goto num_index;
37684                         case IS_LONG:
37685                         case IS_BOOL:
37686                                 hval = Z_LVAL_P(offset);
37687 num_index:
37688                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
37689                                 break;
37690                         case IS_STRING:
37691                                 if (IS_VAR == IS_CONST) {
37692                                         hval = Z_HASH_P(offset);
37693                                 } else {
37694                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
37695                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
37696                                 }
37697                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
37698                                 break;
37699                         case IS_NULL:
37700                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
37701                                 break;
37702                         default:
37703                                 zend_error(E_WARNING, "Illegal offset type");
37704                                 zval_ptr_dtor(&expr_ptr);
37705                                 /* do nothing */
37706                                 break;
37707                 }
37708                 zval_ptr_dtor_nogc(&free_op2.var);
37709         } else {
37710                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
37711         }
37712         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
37713 
37714         }
37715         CHECK_EXCEPTION();
37716         ZEND_VM_NEXT_OPCODE();
37717 }
37718 
37719 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37720 {
37721         USE_OPLINE
37722 
37723         array_init(&EX_T(opline->result.var).tmp_var);
37724         if (IS_CV == IS_UNUSED) {
37725                 ZEND_VM_NEXT_OPCODE();
37726 #if 0 || IS_CV != IS_UNUSED
37727         } else {
37728                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
37729 #endif
37730         }
37731 }
37732 
37733 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37734 {
37735         USE_OPLINE
37736         zval tmp, *varname;
37737         HashTable *target_symbol_table;
37738 
37739 
37740         SAVE_OPLINE();
37741         if (IS_CV == IS_CV &&
37742             IS_VAR == IS_UNUSED &&
37743             (opline->extended_value & ZEND_QUICK_SET)) {
37744                 if (EG(active_symbol_table)) {
37745                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
37746 
37747                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
37748                         EX_CV(opline->op1.var) = NULL;
37749                 } else if (EX_CV(opline->op1.var)) {
37750                         zval_ptr_dtor(EX_CV(opline->op1.var));
37751                         EX_CV(opline->op1.var) = NULL;
37752                 }
37753                 CHECK_EXCEPTION();
37754                 ZEND_VM_NEXT_OPCODE();
37755         }
37756 
37757         varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
37758 
37759         if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
37760                 ZVAL_COPY_VALUE(&tmp, varname);
37761                 zval_copy_ctor(&tmp);
37762                 convert_to_string(&tmp);
37763                 varname = &tmp;
37764         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
37765                 Z_ADDREF_P(varname);
37766         }
37767 
37768         if (IS_VAR != IS_UNUSED) {
37769                 zend_class_entry *ce;
37770 
37771                 if (IS_VAR == IS_CONST) {
37772                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
37773                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
37774                         } else {
37775                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
37776                                 if (UNEXPECTED(EG(exception) != NULL)) {
37777                                         if (IS_CV != IS_CONST && varname == &tmp) {
37778                                                 zval_dtor(&tmp);
37779                                         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
37780                                                 zval_ptr_dtor(&varname);
37781                                         }
37782 
37783                                         HANDLE_EXCEPTION();
37784                                 }
37785                                 if (UNEXPECTED(ce == NULL)) {
37786                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
37787                                 }
37788                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
37789                         }
37790                 } else {
37791                         ce = EX_T(opline->op2.var).class_entry;
37792                 }
37793                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
37794         } else {
37795                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
37796 
37797                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
37798                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
37799         }
37800 
37801         if (IS_CV != IS_CONST && varname == &tmp) {
37802                 zval_dtor(&tmp);
37803         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
37804                 zval_ptr_dtor(&varname);
37805         }
37806 
37807         CHECK_EXCEPTION();
37808         ZEND_VM_NEXT_OPCODE();
37809 }
37810 
37811 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37812 {
37813         USE_OPLINE
37814         zend_free_op free_op2;
37815         zval **container;
37816         zval *offset;
37817         ulong hval;
37818 
37819         SAVE_OPLINE();
37820         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
37821         if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
37822                 SEPARATE_ZVAL_IF_NOT_REF(container);
37823         }
37824         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37825 
37826         if (IS_CV != IS_VAR || container) {
37827                 switch (Z_TYPE_PP(container)) {
37828                         case IS_ARRAY: {
37829                                 HashTable *ht = Z_ARRVAL_PP(container);
37830 
37831                                 switch (Z_TYPE_P(offset)) {
37832                                         case IS_DOUBLE:
37833                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
37834                                                 zend_hash_index_del(ht, hval);
37835                                                 break;
37836                                         case IS_RESOURCE:
37837                                         case IS_BOOL:
37838                                         case IS_LONG:
37839                                                 hval = Z_LVAL_P(offset);
37840                                                 zend_hash_index_del(ht, hval);
37841                                                 break;
37842                                         case IS_STRING:
37843                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
37844                                                         Z_ADDREF_P(offset);
37845                                                 }
37846                                                 if (IS_VAR == IS_CONST) {
37847                                                         hval = Z_HASH_P(offset);
37848                                                 } else {
37849                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
37850                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
37851                                                 }
37852                                                 if (ht == &EG(symbol_table)) {
37853                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
37854                                                 } else {
37855                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
37856                                                 }
37857                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
37858                                                         zval_ptr_dtor(&offset);
37859                                                 }
37860                                                 break;
37861 num_index_dim:
37862                                                 zend_hash_index_del(ht, hval);
37863                                                 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
37864                                                         zval_ptr_dtor(&offset);
37865                                                 }
37866                                                 break;
37867                                         case IS_NULL:
37868                                                 zend_hash_del(ht, "", sizeof(""));
37869                                                 break;
37870                                         default:
37871                                                 zend_error(E_WARNING, "Illegal offset type in unset");
37872                                                 break;
37873                                 }
37874                                 zval_ptr_dtor_nogc(&free_op2.var);
37875                                 break;
37876                         }
37877                         case IS_OBJECT:
37878                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
37879                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
37880                                 }
37881                                 if (0) {
37882                                         MAKE_REAL_ZVAL_PTR(offset);
37883                                 }
37884                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
37885                                 if (0) {
37886                                         zval_ptr_dtor(&offset);
37887                                 } else {
37888                                         zval_ptr_dtor_nogc(&free_op2.var);
37889                                 }
37890                                 break;
37891                         case IS_STRING:
37892                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
37893                                 ZEND_VM_CONTINUE(); /* bailed out before */
37894                         default:
37895                                 zval_ptr_dtor_nogc(&free_op2.var);
37896                                 break;
37897                 }
37898         } else {
37899                 zval_ptr_dtor_nogc(&free_op2.var);
37900         }
37901 
37902         CHECK_EXCEPTION();
37903         ZEND_VM_NEXT_OPCODE();
37904 }
37905 
37906 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37907 {
37908         USE_OPLINE
37909         zend_free_op free_op2;
37910         zval **container;
37911         zval *offset;
37912 
37913         SAVE_OPLINE();
37914         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
37915         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
37916 
37917         if (IS_CV != IS_VAR || container) {
37918                 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
37919                         SEPARATE_ZVAL_IF_NOT_REF(container);
37920                 }
37921                 if (Z_TYPE_PP(container) == IS_OBJECT) {
37922                         if (0) {
37923                                 MAKE_REAL_ZVAL_PTR(offset);
37924                         }
37925                         if (Z_OBJ_HT_P(*container)->unset_property) {
37926                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
37927                         } else {
37928                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
37929                         }
37930                         if (0) {
37931                                 zval_ptr_dtor(&offset);
37932                         } else {
37933                                 zval_ptr_dtor_nogc(&free_op2.var);
37934                         }
37935                 } else {
37936                         zval_ptr_dtor_nogc(&free_op2.var);
37937                 }
37938         } else {
37939                 zval_ptr_dtor_nogc(&free_op2.var);
37940         }
37941 
37942         CHECK_EXCEPTION();
37943         ZEND_VM_NEXT_OPCODE();
37944 }
37945 
37946 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37947 {
37948         USE_OPLINE
37949         zval **value;
37950         zend_bool isset = 1;
37951 
37952         SAVE_OPLINE();
37953         if (IS_CV == IS_CV &&
37954             IS_VAR == IS_UNUSED &&
37955             (opline->extended_value & ZEND_QUICK_SET)) {
37956                 if (EX_CV(opline->op1.var)) {
37957                         value = EX_CV(opline->op1.var);
37958                 } else if (EG(active_symbol_table)) {
37959                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
37960 
37961                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
37962                                 isset = 0;
37963                         }
37964                 } else {
37965                         isset = 0;
37966                 }
37967         } else {
37968                 HashTable *target_symbol_table;
37969 
37970                 zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
37971 
37972                 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
37973                         ZVAL_COPY_VALUE(&tmp, varname);
37974                         zval_copy_ctor(&tmp);
37975                         convert_to_string(&tmp);
37976                         varname = &tmp;
37977                 }
37978 
37979                 if (IS_VAR != IS_UNUSED) {
37980                         zend_class_entry *ce;
37981 
37982                         if (IS_VAR == IS_CONST) {
37983                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
37984                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
37985                                 } else {
37986                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
37987                                         if (UNEXPECTED(ce == NULL)) {
37988                                                 CHECK_EXCEPTION();
37989                                                 ZEND_VM_NEXT_OPCODE();
37990                                         }
37991                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
37992                                 }
37993                         } else {
37994                                 ce = EX_T(opline->op2.var).class_entry;
37995                         }
37996                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
37997                         if (!value) {
37998                                 isset = 0;
37999                         }
38000                 } else {
38001                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
38002                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
38003                                 isset = 0;
38004                         }
38005                 }
38006 
38007                 if (IS_CV != IS_CONST && varname == &tmp) {
38008                         zval_dtor(&tmp);
38009                 }
38010 
38011         }
38012 
38013         if (opline->extended_value & ZEND_ISSET) {
38014                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
38015                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
38016                 } else {
38017                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
38018                 }
38019         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
38020                 if (!isset || !i_zend_is_true(*value)) {
38021                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
38022                 } else {
38023                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
38024                 }
38025         }
38026 
38027         CHECK_EXCEPTION();
38028         ZEND_VM_NEXT_OPCODE();
38029 }
38030 
38031 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
38032 {
38033         USE_OPLINE
38034         zend_free_op free_op2;
38035         zval *container;
38036         zval **value = NULL;
38037         int result = 0;
38038         ulong hval;
38039         zval *offset;
38040 
38041         SAVE_OPLINE();
38042         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
38043         offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
38044 
38045         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
38046                 HashTable *ht;
38047                 int isset = 0;
38048 
38049                 ht = Z_ARRVAL_P(container);
38050 
38051                 switch (Z_TYPE_P(offset)) {
38052                         case IS_DOUBLE:
38053                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
38054                                 goto num_index_prop;
38055                         case IS_RESOURCE:
38056                         case IS_BOOL:
38057                         case IS_LONG:
38058                                 hval = Z_LVAL_P(offset);
38059 num_index_prop:
38060                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
38061                                         isset = 1;
38062                                 }
38063                                 break;
38064                         case IS_STRING:
38065                                 if (IS_VAR == IS_CONST) {
38066                                         hval = Z_HASH_P(offset);
38067                                 } else {
38068                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
38069                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
38070                                 }
38071                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
38072                                         isset = 1;
38073                                 }
38074                                 break;
38075                         case IS_NULL:
38076                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
38077                                         isset = 1;
38078                                 }
38079                                 break;
38080                         default:
38081                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
38082                                 break;
38083                 }
38084 
38085                 if (opline->extended_value & ZEND_ISSET) {
38086                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
38087                                 result = 0;
38088                         } else {
38089                                 result = isset;
38090                         }
38091                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
38092                         if (!isset || !i_zend_is_true(*value)) {
38093                                 result = 0;
38094                         } else {
38095                                 result = 1;
38096                         }
38097                 }
38098                 zval_ptr_dtor_nogc(&free_op2.var);
38099         } else if (Z_TYPE_P(container) == IS_OBJECT) {
38100                 if (0) {
38101                         MAKE_REAL_ZVAL_PTR(offset);
38102                 }
38103                 if (prop_dim) {
38104                         if (Z_OBJ_HT_P(container)->has_property) {
38105                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38106                         } else {
38107                                 zend_error(E_NOTICE, "Trying to check property of non-object");
38108                                 result = 0;
38109                         }
38110                 } else {
38111                         if (Z_OBJ_HT_P(container)->has_dimension) {
38112                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
38113                         } else {
38114                                 zend_error(E_NOTICE, "Trying to check element of non-array");
38115                                 result = 0;
38116                         }
38117                 }
38118                 if (0) {
38119                         zval_ptr_dtor(&offset);
38120                 } else {
38121                         zval_ptr_dtor_nogc(&free_op2.var);
38122                 }
38123         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
38124                 zval tmp;
38125 
38126                 if (Z_TYPE_P(offset) != IS_LONG) {
38127                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
38128                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
38129                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
38130                                 ZVAL_COPY_VALUE(&tmp, offset);
38131                                 zval_copy_ctor(&tmp);
38132                                 convert_to_long(&tmp);
38133                                 offset = &tmp;
38134                         } else {
38135                                 /* can not be converted to proper offset, return "not set" */
38136                                 result = 0;
38137                         }
38138                 }
38139                 if (Z_TYPE_P(offset) == IS_LONG) {
38140                         if (opline->extended_value & ZEND_ISSET) {
38141                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
38142                                         result = 1;
38143                                 }
38144                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
38145                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
38146                                         result = 1;
38147                                 }
38148                         }
38149                 }
38150                 zval_ptr_dtor_nogc(&free_op2.var);
38151         } else {
38152                 zval_ptr_dtor_nogc(&free_op2.var);
38153         }
38154 
38155         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
38156         if (opline->extended_value & ZEND_ISSET) {
38157                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
38158         } else {
38159                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
38160         }
38161 
38162         CHECK_EXCEPTION();
38163         ZEND_VM_NEXT_OPCODE();
38164 }
38165 
38166 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38167 {
38168         return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38169 }
38170 
38171 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38172 {
38173         return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38174 }
38175 
38176 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38177 {
38178         USE_OPLINE
38179 
38180         /* The generator object is stored in return_value_ptr_ptr */
38181         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
38182 
38183         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
38184                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
38185         }
38186 
38187         /* Destroy the previously yielded value */
38188         if (generator->value) {
38189                 zval_ptr_dtor(&generator->value);
38190         }
38191 
38192         /* Destroy the previously yielded key */
38193         if (generator->key) {
38194                 zval_ptr_dtor(&generator->key);
38195         }
38196 
38197         /* Set the new yielded value */
38198         if (IS_CV != IS_UNUSED) {
38199 
38200 
38201                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
38202                         /* Constants and temporary variables aren't yieldable by reference,
38203                          * but we still allow them with a notice. */
38204                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
38205                                 zval *value, *copy;
38206 
38207                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38208 
38209                                 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38210                                 ALLOC_ZVAL(copy);
38211                                 INIT_PZVAL_COPY(copy, value);
38212 
38213                                 /* Temporary variables don't need ctor copying */
38214                                 if (!0) {
38215                                         zval_copy_ctor(copy);
38216                                 }
38217 
38218                                 generator->value = copy;
38219                         } else {
38220                                 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
38221 
38222                                 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
38223                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
38224                                 }
38225 
38226                                 /* If a function call result is yielded and the function did
38227                                  * not return by reference we throw a notice. */
38228                                 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
38229                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
38230                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
38231                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
38232                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38233 
38234                                         Z_ADDREF_PP(value_ptr);
38235                                         generator->value = *value_ptr;
38236                                 } else {
38237                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
38238                                         Z_ADDREF_PP(value_ptr);
38239                                         generator->value = *value_ptr;
38240                                 }
38241 
38242                         }
38243                 } else {
38244                         zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38245 
38246                         /* Consts, temporary variables and references need copying */
38247                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
38248                                 || PZVAL_IS_REF(value)
38249                         ) {
38250                                 zval *copy;
38251 
38252                                 ALLOC_ZVAL(copy);
38253                                 INIT_PZVAL_COPY(copy, value);
38254 
38255                                 /* Temporary variables don't need ctor copying */
38256                                 if (!0) {
38257                                         zval_copy_ctor(copy);
38258                                 }
38259 
38260                                 generator->value = copy;
38261 
38262                         } else {
38263                                 if (IS_CV == IS_CV) {
38264                                         Z_ADDREF_P(value);
38265                                 }
38266                                 generator->value = value;
38267                         }
38268                 }
38269         } else {
38270                 /* If no value was specified yield null */
38271                 Z_ADDREF(EG(uninitialized_zval));
38272                 generator->value = &EG(uninitialized_zval);
38273         }
38274 
38275         /* Set the new yielded key */
38276         if (IS_VAR != IS_UNUSED) {
38277                 zend_free_op free_op2;
38278                 zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
38279 
38280                 /* Consts, temporary variables and references need copying */
38281                 if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
38282                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
38283                 ) {
38284                         zval *copy;
38285 
38286                         ALLOC_ZVAL(copy);
38287                         INIT_PZVAL_COPY(copy, key);
38288 
38289                         /* Temporary variables don't need ctor copying */
38290                         if (!0) {
38291                                 zval_copy_ctor(copy);
38292                         }
38293 
38294                         generator->key = copy;
38295                 } else {
38296                         Z_ADDREF_P(key);
38297                         generator->key = key;
38298                 }
38299 
38300                 if (Z_TYPE_P(generator->key) == IS_LONG
38301                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
38302                 ) {
38303                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
38304                 }
38305 
38306                 zval_ptr_dtor_nogc(&free_op2.var);
38307         } else {
38308                 /* If no key was specified we use auto-increment keys */
38309                 generator->largest_used_integer_key++;
38310 
38311                 ALLOC_INIT_ZVAL(generator->key);
38312                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
38313         }
38314 
38315         if (RETURN_VALUE_USED(opline)) {
38316                 /* If the return value of yield is used set the send
38317                  * target and initialize it to NULL */
38318                 generator->send_target = &EX_T(opline->result.var).var.ptr;
38319                 Z_ADDREF(EG(uninitialized_zval));
38320                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38321         } else {
38322                 generator->send_target = NULL;
38323         }
38324 
38325         /* We increment to the next op, so we are at the correct position when the
38326          * generator is resumed. */
38327         ZEND_VM_INC_OPCODE();
38328 
38329         /* The GOTO VM uses a local opline variable. We need to set the opline
38330          * variable in execute_data so we don't resume at an old position. */
38331         SAVE_OPLINE();
38332 
38333         ZEND_VM_RETURN();
38334 }
38335 
38336 static int ZEND_FASTCALL  ZEND_POW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38337 {
38338         USE_OPLINE
38339         zend_free_op free_op2;
38340 
38341         SAVE_OPLINE();
38342         pow_function(&EX_T(opline->result.var).tmp_var,
38343                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
38344                 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
38345 
38346         zval_ptr_dtor_nogc(&free_op2.var);
38347         CHECK_EXCEPTION();
38348         ZEND_VM_NEXT_OPCODE();
38349 }
38350 
38351 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38352 {
38353         return zend_binary_assign_op_helper_SPEC_CV_VAR(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38354 }
38355 
38356 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
38357 {
38358         USE_OPLINE
38359         zend_free_op free_op_data1;
38360         zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
38361         zval *object;
38362         zval *property = NULL;
38363         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
38364         int have_get_ptr = 0;
38365 
38366         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
38367                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
38368         }
38369 
38370         make_real_object(object_ptr TSRMLS_CC);
38371         object = *object_ptr;
38372 
38373         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38374                 zend_error(E_WARNING, "Attempt to assign property of non-object");
38375 
38376                 FREE_OP(free_op_data1);
38377 
38378                 if (RETURN_VALUE_USED(opline)) {
38379                         PZVAL_LOCK(&EG(uninitialized_zval));
38380                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38381                 }
38382         } else {
38383                 /* here we are sure we are dealing with an object */
38384                 if (0) {
38385                         MAKE_REAL_ZVAL_PTR(property);
38386                 }
38387 
38388                 /* here property is a string */
38389                 if (opline->extended_value == ZEND_ASSIGN_OBJ
38390                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
38391                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38392                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
38393                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
38394 
38395                                 have_get_ptr = 1;
38396                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
38397                                 if (RETURN_VALUE_USED(opline)) {
38398                                         PZVAL_LOCK(*zptr);
38399                                         EX_T(opline->result.var).var.ptr = *zptr;
38400                                 }
38401                         }
38402                 }
38403 
38404                 if (!have_get_ptr) {
38405                         zval *z = NULL;
38406 
38407                         Z_ADDREF_P(object);
38408                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
38409                                 if (Z_OBJ_HT_P(object)->read_property) {
38410                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38411                                 }
38412                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
38413                                 if (Z_OBJ_HT_P(object)->read_dimension) {
38414                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
38415                                 }
38416                         }
38417                         if (z) {
38418                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
38419                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
38420 
38421                                         if (Z_REFCOUNT_P(z) == 0) {
38422                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
38423                                                 zval_dtor(z);
38424                                                 FREE_ZVAL(z);
38425                                         }
38426                                         z = value;
38427                                 }
38428                                 Z_ADDREF_P(z);
38429                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
38430                                 binary_op(z, z, value TSRMLS_CC);
38431                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
38432                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38433                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
38434                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
38435                                 }
38436                                 if (RETURN_VALUE_USED(opline)) {
38437                                         PZVAL_LOCK(z);
38438                                         EX_T(opline->result.var).var.ptr = z;
38439                                 }
38440                                 zval_ptr_dtor(&z);
38441                         } else {
38442                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
38443                                 if (RETURN_VALUE_USED(opline)) {
38444                                         PZVAL_LOCK(&EG(uninitialized_zval));
38445                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38446                                 }
38447                         }
38448                         zval_ptr_dtor(&object);
38449                 }
38450 
38451                 if (0) {
38452                         zval_ptr_dtor(&property);
38453                 } else {
38454 
38455                 }
38456                 FREE_OP(free_op_data1);
38457         }
38458 
38459         /* assign_obj has two opcodes! */
38460         CHECK_EXCEPTION();
38461         ZEND_VM_INC_OPCODE();
38462         ZEND_VM_NEXT_OPCODE();
38463 }
38464 
38465 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
38466 {
38467         USE_OPLINE
38468         zend_free_op free_op_data2, free_op_data1;
38469         zval **var_ptr;
38470         zval *value;
38471 
38472         SAVE_OPLINE();
38473         switch (opline->extended_value) {
38474                 case ZEND_ASSIGN_OBJ:
38475                         return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38476                         break;
38477                 case ZEND_ASSIGN_DIM: {
38478                                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
38479 
38480                                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
38481                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
38482                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
38483                                         if (IS_CV == IS_VAR && !0) {
38484                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
38485                                         }
38486                                         return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38487                                 } else {
38488                                         zval *dim = NULL;
38489 
38490                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
38491                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
38492                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
38493                                 }
38494                         }
38495                         break;
38496                 default:
38497                         value = NULL;
38498                         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
38499                         /* do nothing */
38500                         break;
38501         }
38502 
38503         if (UNEXPECTED(var_ptr == NULL)) {
38504                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
38505         }
38506 
38507         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
38508                 if (RETURN_VALUE_USED(opline)) {
38509                         PZVAL_LOCK(&EG(uninitialized_zval));
38510                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38511                 }
38512 
38513 
38514                 CHECK_EXCEPTION();
38515                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
38516                         ZEND_VM_INC_OPCODE();
38517                 }
38518                 ZEND_VM_NEXT_OPCODE();
38519         }
38520 
38521         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
38522 
38523         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
38524            && Z_OBJ_HANDLER_PP(var_ptr, get)
38525            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
38526                 /* proxy object */
38527                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
38528                 Z_ADDREF_P(objval);
38529                 binary_op(objval, objval, value TSRMLS_CC);
38530                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
38531                 zval_ptr_dtor(&objval);
38532         } else {
38533                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
38534         }
38535 
38536         if (RETURN_VALUE_USED(opline)) {
38537                 PZVAL_LOCK(*var_ptr);
38538                 EX_T(opline->result.var).var.ptr = *var_ptr;
38539         }
38540 
38541         if (opline->extended_value == ZEND_ASSIGN_DIM) {
38542                 FREE_OP(free_op_data1);
38543                 FREE_OP_VAR_PTR(free_op_data2);
38544 
38545                 CHECK_EXCEPTION();
38546                 ZEND_VM_INC_OPCODE();
38547         } else {
38548 
38549                 CHECK_EXCEPTION();
38550         }
38551         ZEND_VM_NEXT_OPCODE();
38552 }
38553 
38554 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38555 {
38556         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38557 }
38558 
38559 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38560 {
38561         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38562 }
38563 
38564 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38565 {
38566         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38567 }
38568 
38569 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38570 {
38571         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38572 }
38573 
38574 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38575 {
38576         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38577 }
38578 
38579 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38580 {
38581         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38582 }
38583 
38584 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38585 {
38586         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38587 }
38588 
38589 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38590 {
38591         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38592 }
38593 
38594 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38595 {
38596         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38597 }
38598 
38599 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38600 {
38601         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38602 }
38603 
38604 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38605 {
38606         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38607 }
38608 
38609 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
38610 {
38611         USE_OPLINE
38612         zend_free_op free_op1;
38613         zval *varname;
38614         zval **retval;
38615         zval tmp_varname;
38616         HashTable *target_symbol_table;
38617         ulong hash_value;
38618 
38619         SAVE_OPLINE();
38620         varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38621 
38622         if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
38623                 ZVAL_COPY_VALUE(&tmp_varname, varname);
38624                 zval_copy_ctor(&tmp_varname);
38625                 Z_SET_REFCOUNT(tmp_varname, 1);
38626                 Z_UNSET_ISREF(tmp_varname);
38627                 convert_to_string(&tmp_varname);
38628                 varname = &tmp_varname;
38629         }
38630 
38631         if (IS_UNUSED != IS_UNUSED) {
38632                 zend_class_entry *ce;
38633 
38634                 if (IS_UNUSED == IS_CONST) {
38635                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
38636                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
38637                         } else {
38638                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
38639                                 if (UNEXPECTED(ce == NULL)) {
38640                                         if (IS_CV != IS_CONST && varname == &tmp_varname) {
38641                                                 zval_dtor(&tmp_varname);
38642                                         }
38643 
38644                                         CHECK_EXCEPTION();
38645                                         ZEND_VM_NEXT_OPCODE();
38646                                 }
38647                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
38648                         }
38649                 } else {
38650                         ce = EX_T(opline->op2.var).class_entry;
38651                 }
38652                 retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
38653 
38654         } else {
38655                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
38656 /*
38657                 if (!target_symbol_table) {
38658                         CHECK_EXCEPTION();
38659                         ZEND_VM_NEXT_OPCODE();
38660                 }
38661 */
38662                 if (IS_CV == IS_CONST) {
38663                         hash_value = Z_HASH_P(varname);
38664                 } else {
38665                         hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
38666                 }
38667 
38668                 if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
38669                         switch (type) {
38670                                 case BP_VAR_R:
38671                                 case BP_VAR_UNSET:
38672                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
38673                                         /* break missing intentionally */
38674                                 case BP_VAR_IS:
38675                                         retval = &EG(uninitialized_zval_ptr);
38676                                         break;
38677                                 case BP_VAR_RW:
38678                                         zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
38679                                         /* break missing intentionally */
38680                                 case BP_VAR_W:
38681                                         Z_ADDREF_P(&EG(uninitialized_zval));
38682                                         zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
38683                                         break;
38684                                 EMPTY_SWITCH_DEFAULT_CASE()
38685                         }
38686                 }
38687                 switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
38688                         case ZEND_FETCH_GLOBAL:
38689                                 if (IS_CV != IS_TMP_VAR) {
38690 
38691                                 }
38692                                 break;
38693                         case ZEND_FETCH_LOCAL:
38694 
38695                                 break;
38696                         case ZEND_FETCH_STATIC:
38697                                 zval_update_constant(retval, 1 TSRMLS_CC);
38698                                 break;
38699                         case ZEND_FETCH_GLOBAL_LOCK:
38700                                 if (IS_CV == IS_VAR && !free_op1.var) {
38701                                         PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
38702                                 }
38703                                 break;
38704                 }
38705         }
38706 
38707 
38708         if (IS_CV != IS_CONST && varname == &tmp_varname) {
38709                 zval_dtor(&tmp_varname);
38710         }
38711         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
38712                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
38713         }
38714         PZVAL_LOCK(*retval);
38715         switch (type) {
38716                 case BP_VAR_R:
38717                 case BP_VAR_IS:
38718                         EX_T(opline->result.var).var.ptr = *retval;
38719                         break;
38720                 case BP_VAR_UNSET: {
38721                         zend_free_op free_res;
38722 
38723                         PZVAL_UNLOCK(*retval, &free_res);
38724                         if (retval != &EG(uninitialized_zval_ptr)) {
38725                                 SEPARATE_ZVAL_IF_NOT_REF(retval);
38726                         }
38727                         PZVAL_LOCK(*retval);
38728                         FREE_OP_VAR_PTR(free_res);
38729                 }
38730                 /* break missing intentionally */
38731                 default:
38732                         EX_T(opline->result.var).var.ptr_ptr = retval;
38733                         break;
38734         }
38735         CHECK_EXCEPTION();
38736         ZEND_VM_NEXT_OPCODE();
38737 }
38738 
38739 static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38740 {
38741         return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38742 }
38743 
38744 static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38745 {
38746         return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38747 }
38748 
38749 static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38750 {
38751         return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38752 }
38753 
38754 static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38755 {
38756         USE_OPLINE
38757 
38758         return zend_fetch_var_address_helper_SPEC_CV_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38759 }
38760 
38761 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38762 {
38763         return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38764 }
38765 
38766 static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38767 {
38768         return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
38769 }
38770 
38771 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38772 {
38773         USE_OPLINE
38774         zend_free_op free_op1;
38775         zval **container;
38776 
38777         SAVE_OPLINE();
38778         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
38779 
38780         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
38781                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
38782         }
38783         zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
38784 
38785         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
38786                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
38787         }
38788 
38789         /* We are going to assign the result by reference */
38790         if (UNEXPECTED(opline->extended_value != 0)) {
38791                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
38792 
38793                 if (retval_ptr) {
38794                         Z_DELREF_PP(retval_ptr);
38795                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
38796                         Z_ADDREF_PP(retval_ptr);
38797                 }
38798         }
38799 
38800         CHECK_EXCEPTION();
38801         ZEND_VM_NEXT_OPCODE();
38802 }
38803 
38804 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38805 {
38806         USE_OPLINE
38807         zend_free_op free_op1;
38808         zval **container;
38809 
38810         SAVE_OPLINE();
38811         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
38812 
38813         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
38814                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
38815         }
38816         zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
38817 
38818         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
38819                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
38820         }
38821 
38822         CHECK_EXCEPTION();
38823         ZEND_VM_NEXT_OPCODE();
38824 }
38825 
38826 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38827 {
38828         USE_OPLINE
38829         zend_free_op free_op1;
38830 
38831         SAVE_OPLINE();
38832 
38833         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
38834                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
38835                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
38836                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
38837                 }
38838                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
38839                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
38840                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
38841                 }
38842 
38843 
38844         } else {
38845                 zval *container;
38846 
38847                 if (IS_UNUSED == IS_UNUSED) {
38848                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
38849                 }
38850                 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38851                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
38852 
38853 
38854         }
38855         CHECK_EXCEPTION();
38856         ZEND_VM_NEXT_OPCODE();
38857 }
38858 
38859 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38860 {
38861         USE_OPLINE
38862 
38863         zval **object_ptr;
38864 
38865         SAVE_OPLINE();
38866         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
38867 
38868         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
38869                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
38870         }
38871         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
38872 
38873                 zval *property_name = NULL;
38874 
38875                 if (0) {
38876                         MAKE_REAL_ZVAL_PTR(property_name);
38877                 }
38878                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
38879                 if (0) {
38880                         zval_ptr_dtor(&property_name);
38881                 } else {
38882 
38883                 }
38884         } else {
38885                 zend_free_op free_op_data1, free_op_data2;
38886                 zval *value;
38887                 zval *dim = NULL;
38888                 zval **variable_ptr_ptr;
38889 
38890                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC);
38891 
38892                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
38893                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
38894                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
38895                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
38896                                 if (RETURN_VALUE_USED(opline)) {
38897                                         zval *retval;
38898 
38899                                         ALLOC_ZVAL(retval);
38900                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
38901                                         INIT_PZVAL(retval);
38902                                         EX_T(opline->result.var).var.ptr = retval;
38903                                 }
38904                         } else if (RETURN_VALUE_USED(opline)) {
38905                                 PZVAL_LOCK(&EG(uninitialized_zval));
38906                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38907                         }
38908                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
38909                         if (IS_TMP_FREE(free_op_data1)) {
38910                                 zval_dtor(value);
38911                         }
38912                         if (RETURN_VALUE_USED(opline)) {
38913                                 PZVAL_LOCK(&EG(uninitialized_zval));
38914                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
38915                         }
38916                 } else {
38917                         if ((opline+1)->op1_type == IS_TMP_VAR) {
38918                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
38919                         } else if ((opline+1)->op1_type == IS_CONST) {
38920                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
38921                         } else {
38922                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
38923                         }
38924                         if (RETURN_VALUE_USED(opline)) {
38925                                 PZVAL_LOCK(value);
38926                                 EX_T(opline->result.var).var.ptr = value;
38927                         }
38928                 }
38929                 FREE_OP_VAR_PTR(free_op_data2);
38930                 FREE_OP_IF_VAR(free_op_data1);
38931         }
38932 
38933         /* assign_dim has two opcodes! */
38934         CHECK_EXCEPTION();
38935         ZEND_VM_INC_OPCODE();
38936         ZEND_VM_NEXT_OPCODE();
38937 }
38938 
38939 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38940 {
38941         USE_OPLINE
38942 
38943         zval *expr_ptr;
38944 
38945         SAVE_OPLINE();
38946         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
38947                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
38948 
38949                 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
38950                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
38951                 }
38952                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
38953                 expr_ptr = *expr_ptr_ptr;
38954                 Z_ADDREF_P(expr_ptr);
38955         } else {
38956                 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
38957                 if (0) { /* temporary variable */
38958                         zval *new_expr;
38959 
38960                         ALLOC_ZVAL(new_expr);
38961                         INIT_PZVAL_COPY(new_expr, expr_ptr);
38962                         expr_ptr = new_expr;
38963                 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
38964                         zval *new_expr;
38965 
38966                         ALLOC_ZVAL(new_expr);
38967                         INIT_PZVAL_COPY(new_expr, expr_ptr);
38968                         expr_ptr = new_expr;
38969                         zendi_zval_copy_ctor(*expr_ptr);
38970 
38971                 } else if (IS_CV == IS_CV) {
38972                         Z_ADDREF_P(expr_ptr);
38973                 }
38974         }
38975 
38976         if (IS_UNUSED != IS_UNUSED) {
38977 
38978                 zval *offset = NULL;
38979                 ulong hval;
38980 
38981                 switch (Z_TYPE_P(offset)) {
38982                         case IS_DOUBLE:
38983                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
38984                                 goto num_index;
38985                         case IS_LONG:
38986                         case IS_BOOL:
38987                                 hval = Z_LVAL_P(offset);
38988 num_index:
38989                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
38990                                 break;
38991                         case IS_STRING:
38992                                 if (IS_UNUSED == IS_CONST) {
38993                                         hval = Z_HASH_P(offset);
38994                                 } else {
38995                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
38996                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
38997                                 }
38998                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
38999                                 break;
39000                         case IS_NULL:
39001                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
39002                                 break;
39003                         default:
39004                                 zend_error(E_WARNING, "Illegal offset type");
39005                                 zval_ptr_dtor(&expr_ptr);
39006                                 /* do nothing */
39007                                 break;
39008                 }
39009 
39010         } else {
39011                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
39012         }
39013         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
39014 
39015         }
39016         CHECK_EXCEPTION();
39017         ZEND_VM_NEXT_OPCODE();
39018 }
39019 
39020 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39021 {
39022         USE_OPLINE
39023 
39024         array_init(&EX_T(opline->result.var).tmp_var);
39025         if (IS_CV == IS_UNUSED) {
39026                 ZEND_VM_NEXT_OPCODE();
39027 #if 0 || IS_CV != IS_UNUSED
39028         } else {
39029                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39030 #endif
39031         }
39032 }
39033 
39034 static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39035 {
39036         USE_OPLINE
39037         zval tmp, *varname;
39038         HashTable *target_symbol_table;
39039 
39040 
39041         SAVE_OPLINE();
39042         if (IS_CV == IS_CV &&
39043             IS_UNUSED == IS_UNUSED &&
39044             (opline->extended_value & ZEND_QUICK_SET)) {
39045                 if (EG(active_symbol_table)) {
39046                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
39047 
39048                         zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
39049                         EX_CV(opline->op1.var) = NULL;
39050                 } else if (EX_CV(opline->op1.var)) {
39051                         zval_ptr_dtor(EX_CV(opline->op1.var));
39052                         EX_CV(opline->op1.var) = NULL;
39053                 }
39054                 CHECK_EXCEPTION();
39055                 ZEND_VM_NEXT_OPCODE();
39056         }
39057 
39058         varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
39059 
39060         if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
39061                 ZVAL_COPY_VALUE(&tmp, varname);
39062                 zval_copy_ctor(&tmp);
39063                 convert_to_string(&tmp);
39064                 varname = &tmp;
39065         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
39066                 Z_ADDREF_P(varname);
39067         }
39068 
39069         if (IS_UNUSED != IS_UNUSED) {
39070                 zend_class_entry *ce;
39071 
39072                 if (IS_UNUSED == IS_CONST) {
39073                         if (CACHED_PTR(opline->op2.literal->cache_slot)) {
39074                                 ce = CACHED_PTR(opline->op2.literal->cache_slot);
39075                         } else {
39076                                 ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
39077                                 if (UNEXPECTED(EG(exception) != NULL)) {
39078                                         if (IS_CV != IS_CONST && varname == &tmp) {
39079                                                 zval_dtor(&tmp);
39080                                         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
39081                                                 zval_ptr_dtor(&varname);
39082                                         }
39083 
39084                                         HANDLE_EXCEPTION();
39085                                 }
39086                                 if (UNEXPECTED(ce == NULL)) {
39087                                         zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
39088                                 }
39089                                 CACHE_PTR(opline->op2.literal->cache_slot, ce);
39090                         }
39091                 } else {
39092                         ce = EX_T(opline->op2.var).class_entry;
39093                 }
39094                 zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
39095         } else {
39096                 ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
39097 
39098                 target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
39099                 zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
39100         }
39101 
39102         if (IS_CV != IS_CONST && varname == &tmp) {
39103                 zval_dtor(&tmp);
39104         } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
39105                 zval_ptr_dtor(&varname);
39106         }
39107 
39108         CHECK_EXCEPTION();
39109         ZEND_VM_NEXT_OPCODE();
39110 }
39111 
39112 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39113 {
39114         USE_OPLINE
39115         zval **value;
39116         zend_bool isset = 1;
39117 
39118         SAVE_OPLINE();
39119         if (IS_CV == IS_CV &&
39120             IS_UNUSED == IS_UNUSED &&
39121             (opline->extended_value & ZEND_QUICK_SET)) {
39122                 if (EX_CV(opline->op1.var)) {
39123                         value = EX_CV(opline->op1.var);
39124                 } else if (EG(active_symbol_table)) {
39125                         zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
39126 
39127                         if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
39128                                 isset = 0;
39129                         }
39130                 } else {
39131                         isset = 0;
39132                 }
39133         } else {
39134                 HashTable *target_symbol_table;
39135 
39136                 zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
39137 
39138                 if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
39139                         ZVAL_COPY_VALUE(&tmp, varname);
39140                         zval_copy_ctor(&tmp);
39141                         convert_to_string(&tmp);
39142                         varname = &tmp;
39143                 }
39144 
39145                 if (IS_UNUSED != IS_UNUSED) {
39146                         zend_class_entry *ce;
39147 
39148                         if (IS_UNUSED == IS_CONST) {
39149                                 if (CACHED_PTR(opline->op2.literal->cache_slot)) {
39150                                         ce = CACHED_PTR(opline->op2.literal->cache_slot);
39151                                 } else {
39152                                         ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
39153                                         if (UNEXPECTED(ce == NULL)) {
39154                                                 CHECK_EXCEPTION();
39155                                                 ZEND_VM_NEXT_OPCODE();
39156                                         }
39157                                         CACHE_PTR(opline->op2.literal->cache_slot, ce);
39158                                 }
39159                         } else {
39160                                 ce = EX_T(opline->op2.var).class_entry;
39161                         }
39162                         value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
39163                         if (!value) {
39164                                 isset = 0;
39165                         }
39166                 } else {
39167                         target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
39168                         if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
39169                                 isset = 0;
39170                         }
39171                 }
39172 
39173                 if (IS_CV != IS_CONST && varname == &tmp) {
39174                         zval_dtor(&tmp);
39175                 }
39176 
39177         }
39178 
39179         if (opline->extended_value & ZEND_ISSET) {
39180                 if (isset && Z_TYPE_PP(value) != IS_NULL) {
39181                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
39182                 } else {
39183                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
39184                 }
39185         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
39186                 if (!isset || !i_zend_is_true(*value)) {
39187                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
39188                 } else {
39189                         ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
39190                 }
39191         }
39192 
39193         CHECK_EXCEPTION();
39194         ZEND_VM_NEXT_OPCODE();
39195 }
39196 
39197 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39198 {
39199         USE_OPLINE
39200 
39201         /* The generator object is stored in return_value_ptr_ptr */
39202         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
39203 
39204         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
39205                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
39206         }
39207 
39208         /* Destroy the previously yielded value */
39209         if (generator->value) {
39210                 zval_ptr_dtor(&generator->value);
39211         }
39212 
39213         /* Destroy the previously yielded key */
39214         if (generator->key) {
39215                 zval_ptr_dtor(&generator->key);
39216         }
39217 
39218         /* Set the new yielded value */
39219         if (IS_CV != IS_UNUSED) {
39220 
39221 
39222                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
39223                         /* Constants and temporary variables aren't yieldable by reference,
39224                          * but we still allow them with a notice. */
39225                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
39226                                 zval *value, *copy;
39227 
39228                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
39229 
39230                                 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
39231                                 ALLOC_ZVAL(copy);
39232                                 INIT_PZVAL_COPY(copy, value);
39233 
39234                                 /* Temporary variables don't need ctor copying */
39235                                 if (!0) {
39236                                         zval_copy_ctor(copy);
39237                                 }
39238 
39239                                 generator->value = copy;
39240                         } else {
39241                                 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
39242 
39243                                 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
39244                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
39245                                 }
39246 
39247                                 /* If a function call result is yielded and the function did
39248                                  * not return by reference we throw a notice. */
39249                                 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
39250                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
39251                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
39252                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
39253                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
39254 
39255                                         Z_ADDREF_PP(value_ptr);
39256                                         generator->value = *value_ptr;
39257                                 } else {
39258                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
39259                                         Z_ADDREF_PP(value_ptr);
39260                                         generator->value = *value_ptr;
39261                                 }
39262 
39263                         }
39264                 } else {
39265                         zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
39266 
39267                         /* Consts, temporary variables and references need copying */
39268                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
39269                                 || PZVAL_IS_REF(value)
39270                         ) {
39271                                 zval *copy;
39272 
39273                                 ALLOC_ZVAL(copy);
39274                                 INIT_PZVAL_COPY(copy, value);
39275 
39276                                 /* Temporary variables don't need ctor copying */
39277                                 if (!0) {
39278                                         zval_copy_ctor(copy);
39279                                 }
39280 
39281                                 generator->value = copy;
39282 
39283                         } else {
39284                                 if (IS_CV == IS_CV) {
39285                                         Z_ADDREF_P(value);
39286                                 }
39287                                 generator->value = value;
39288                         }
39289                 }
39290         } else {
39291                 /* If no value was specified yield null */
39292                 Z_ADDREF(EG(uninitialized_zval));
39293                 generator->value = &EG(uninitialized_zval);
39294         }
39295 
39296         /* Set the new yielded key */
39297         if (IS_UNUSED != IS_UNUSED) {
39298 
39299                 zval *key = NULL;
39300 
39301                 /* Consts, temporary variables and references need copying */
39302                 if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
39303                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
39304                 ) {
39305                         zval *copy;
39306 
39307                         ALLOC_ZVAL(copy);
39308                         INIT_PZVAL_COPY(copy, key);
39309 
39310                         /* Temporary variables don't need ctor copying */
39311                         if (!0) {
39312                                 zval_copy_ctor(copy);
39313                         }
39314 
39315                         generator->key = copy;
39316                 } else {
39317                         Z_ADDREF_P(key);
39318                         generator->key = key;
39319                 }
39320 
39321                 if (Z_TYPE_P(generator->key) == IS_LONG
39322                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
39323                 ) {
39324                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
39325                 }
39326 
39327         } else {
39328                 /* If no key was specified we use auto-increment keys */
39329                 generator->largest_used_integer_key++;
39330 
39331                 ALLOC_INIT_ZVAL(generator->key);
39332                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
39333         }
39334 
39335         if (RETURN_VALUE_USED(opline)) {
39336                 /* If the return value of yield is used set the send
39337                  * target and initialize it to NULL */
39338                 generator->send_target = &EX_T(opline->result.var).var.ptr;
39339                 Z_ADDREF(EG(uninitialized_zval));
39340                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39341         } else {
39342                 generator->send_target = NULL;
39343         }
39344 
39345         /* We increment to the next op, so we are at the correct position when the
39346          * generator is resumed. */
39347         ZEND_VM_INC_OPCODE();
39348 
39349         /* The GOTO VM uses a local opline variable. We need to set the opline
39350          * variable in execute_data so we don't resume at an old position. */
39351         SAVE_OPLINE();
39352 
39353         ZEND_VM_RETURN();
39354 }
39355 
39356 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39357 {
39358         return zend_binary_assign_op_helper_SPEC_CV_UNUSED(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39359 }
39360 
39361 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39362 {
39363         USE_OPLINE
39364 
39365 
39366         SAVE_OPLINE();
39367         fast_add_function(&EX_T(opline->result.var).tmp_var,
39368                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39369                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39370 
39371 
39372         CHECK_EXCEPTION();
39373         ZEND_VM_NEXT_OPCODE();
39374 }
39375 
39376 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39377 {
39378         USE_OPLINE
39379 
39380 
39381         SAVE_OPLINE();
39382         fast_sub_function(&EX_T(opline->result.var).tmp_var,
39383                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39384                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39385 
39386 
39387         CHECK_EXCEPTION();
39388         ZEND_VM_NEXT_OPCODE();
39389 }
39390 
39391 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39392 {
39393         USE_OPLINE
39394 
39395 
39396         SAVE_OPLINE();
39397         fast_mul_function(&EX_T(opline->result.var).tmp_var,
39398                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39399                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39400 
39401 
39402         CHECK_EXCEPTION();
39403         ZEND_VM_NEXT_OPCODE();
39404 }
39405 
39406 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39407 {
39408         USE_OPLINE
39409 
39410 
39411         SAVE_OPLINE();
39412         fast_div_function(&EX_T(opline->result.var).tmp_var,
39413                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39414                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39415 
39416 
39417         CHECK_EXCEPTION();
39418         ZEND_VM_NEXT_OPCODE();
39419 }
39420 
39421 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39422 {
39423         USE_OPLINE
39424 
39425 
39426         SAVE_OPLINE();
39427         fast_mod_function(&EX_T(opline->result.var).tmp_var,
39428                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39429                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39430 
39431 
39432         CHECK_EXCEPTION();
39433         ZEND_VM_NEXT_OPCODE();
39434 }
39435 
39436 static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39437 {
39438         USE_OPLINE
39439 
39440 
39441         SAVE_OPLINE();
39442         shift_left_function(&EX_T(opline->result.var).tmp_var,
39443                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39444                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39445 
39446 
39447         CHECK_EXCEPTION();
39448         ZEND_VM_NEXT_OPCODE();
39449 }
39450 
39451 static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39452 {
39453         USE_OPLINE
39454 
39455 
39456         SAVE_OPLINE();
39457         shift_right_function(&EX_T(opline->result.var).tmp_var,
39458                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39459                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39460 
39461 
39462         CHECK_EXCEPTION();
39463         ZEND_VM_NEXT_OPCODE();
39464 }
39465 
39466 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39467 {
39468         USE_OPLINE
39469 
39470 
39471         SAVE_OPLINE();
39472         concat_function(&EX_T(opline->result.var).tmp_var,
39473                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39474                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39475 
39476 
39477         CHECK_EXCEPTION();
39478         ZEND_VM_NEXT_OPCODE();
39479 }
39480 
39481 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39482 {
39483         USE_OPLINE
39484 
39485 
39486         SAVE_OPLINE();
39487         is_identical_function(&EX_T(opline->result.var).tmp_var,
39488                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39489                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39490 
39491 
39492         CHECK_EXCEPTION();
39493         ZEND_VM_NEXT_OPCODE();
39494 }
39495 
39496 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39497 {
39498         USE_OPLINE
39499 
39500         zval *result = &EX_T(opline->result.var).tmp_var;
39501 
39502         SAVE_OPLINE();
39503         is_identical_function(result,
39504                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39505                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39506         Z_LVAL_P(result) = !Z_LVAL_P(result);
39507 
39508 
39509         CHECK_EXCEPTION();
39510         ZEND_VM_NEXT_OPCODE();
39511 }
39512 
39513 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39514 {
39515         USE_OPLINE
39516 
39517         zval *result = &EX_T(opline->result.var).tmp_var;
39518 
39519         SAVE_OPLINE();
39520         ZVAL_BOOL(result, fast_equal_function(result,
39521                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39522                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
39523 
39524 
39525         CHECK_EXCEPTION();
39526         ZEND_VM_NEXT_OPCODE();
39527 }
39528 
39529 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39530 {
39531         USE_OPLINE
39532 
39533         zval *result = &EX_T(opline->result.var).tmp_var;
39534 
39535         SAVE_OPLINE();
39536         ZVAL_BOOL(result, fast_not_equal_function(result,
39537                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39538                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
39539 
39540 
39541         CHECK_EXCEPTION();
39542         ZEND_VM_NEXT_OPCODE();
39543 }
39544 
39545 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39546 {
39547         USE_OPLINE
39548 
39549         zval *result = &EX_T(opline->result.var).tmp_var;
39550 
39551         SAVE_OPLINE();
39552         ZVAL_BOOL(result, fast_is_smaller_function(result,
39553                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39554                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
39555 
39556 
39557         CHECK_EXCEPTION();
39558         ZEND_VM_NEXT_OPCODE();
39559 }
39560 
39561 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39562 {
39563         USE_OPLINE
39564 
39565         zval *result = &EX_T(opline->result.var).tmp_var;
39566 
39567         SAVE_OPLINE();
39568         ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
39569                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39570                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
39571 
39572 
39573         CHECK_EXCEPTION();
39574         ZEND_VM_NEXT_OPCODE();
39575 }
39576 
39577 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39578 {
39579         USE_OPLINE
39580 
39581 
39582         SAVE_OPLINE();
39583         bitwise_or_function(&EX_T(opline->result.var).tmp_var,
39584                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39585                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39586 
39587 
39588         CHECK_EXCEPTION();
39589         ZEND_VM_NEXT_OPCODE();
39590 }
39591 
39592 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39593 {
39594         USE_OPLINE
39595 
39596 
39597         SAVE_OPLINE();
39598         bitwise_and_function(&EX_T(opline->result.var).tmp_var,
39599                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39600                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39601 
39602 
39603         CHECK_EXCEPTION();
39604         ZEND_VM_NEXT_OPCODE();
39605 }
39606 
39607 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39608 {
39609         USE_OPLINE
39610 
39611 
39612         SAVE_OPLINE();
39613         bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
39614                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39615                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39616 
39617 
39618         CHECK_EXCEPTION();
39619         ZEND_VM_NEXT_OPCODE();
39620 }
39621 
39622 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39623 {
39624         USE_OPLINE
39625 
39626 
39627         SAVE_OPLINE();
39628         boolean_xor_function(&EX_T(opline->result.var).tmp_var,
39629                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
39630                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
39631 
39632 
39633         CHECK_EXCEPTION();
39634         ZEND_VM_NEXT_OPCODE();
39635 }
39636 
39637 static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
39638 {
39639         USE_OPLINE
39640         zend_free_op free_op_data1;
39641         zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
39642         zval *object;
39643         zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
39644         zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
39645         int have_get_ptr = 0;
39646 
39647         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
39648                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
39649         }
39650 
39651         make_real_object(object_ptr TSRMLS_CC);
39652         object = *object_ptr;
39653 
39654         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39655                 zend_error(E_WARNING, "Attempt to assign property of non-object");
39656 
39657                 FREE_OP(free_op_data1);
39658 
39659                 if (RETURN_VALUE_USED(opline)) {
39660                         PZVAL_LOCK(&EG(uninitialized_zval));
39661                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39662                 }
39663         } else {
39664                 /* here we are sure we are dealing with an object */
39665                 if (0) {
39666                         MAKE_REAL_ZVAL_PTR(property);
39667                 }
39668 
39669                 /* here property is a string */
39670                 if (opline->extended_value == ZEND_ASSIGN_OBJ
39671                         && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
39672                         zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39673                         if (zptr != NULL) {                     /* NULL means no success in getting PTR */
39674                                 SEPARATE_ZVAL_IF_NOT_REF(zptr);
39675 
39676                                 have_get_ptr = 1;
39677                                 binary_op(*zptr, *zptr, value TSRMLS_CC);
39678                                 if (RETURN_VALUE_USED(opline)) {
39679                                         PZVAL_LOCK(*zptr);
39680                                         EX_T(opline->result.var).var.ptr = *zptr;
39681                                 }
39682                         }
39683                 }
39684 
39685                 if (!have_get_ptr) {
39686                         zval *z = NULL;
39687 
39688                         Z_ADDREF_P(object);
39689                         if (opline->extended_value == ZEND_ASSIGN_OBJ) {
39690                                 if (Z_OBJ_HT_P(object)->read_property) {
39691                                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39692                                 }
39693                         } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
39694                                 if (Z_OBJ_HT_P(object)->read_dimension) {
39695                                         z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
39696                                 }
39697                         }
39698                         if (z) {
39699                                 if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
39700                                         zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
39701 
39702                                         if (Z_REFCOUNT_P(z) == 0) {
39703                                                 GC_REMOVE_ZVAL_FROM_BUFFER(z);
39704                                                 zval_dtor(z);
39705                                                 FREE_ZVAL(z);
39706                                         }
39707                                         z = value;
39708                                 }
39709                                 Z_ADDREF_P(z);
39710                                 SEPARATE_ZVAL_IF_NOT_REF(&z);
39711                                 binary_op(z, z, value TSRMLS_CC);
39712                                 if (opline->extended_value == ZEND_ASSIGN_OBJ) {
39713                                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39714                                 } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
39715                                         Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
39716                                 }
39717                                 if (RETURN_VALUE_USED(opline)) {
39718                                         PZVAL_LOCK(z);
39719                                         EX_T(opline->result.var).var.ptr = z;
39720                                 }
39721                                 zval_ptr_dtor(&z);
39722                         } else {
39723                                 zend_error(E_WARNING, "Attempt to assign property of non-object");
39724                                 if (RETURN_VALUE_USED(opline)) {
39725                                         PZVAL_LOCK(&EG(uninitialized_zval));
39726                                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39727                                 }
39728                         }
39729                         zval_ptr_dtor(&object);
39730                 }
39731 
39732                 if (0) {
39733                         zval_ptr_dtor(&property);
39734                 } else {
39735 
39736                 }
39737                 FREE_OP(free_op_data1);
39738         }
39739 
39740         /* assign_obj has two opcodes! */
39741         CHECK_EXCEPTION();
39742         ZEND_VM_INC_OPCODE();
39743         ZEND_VM_NEXT_OPCODE();
39744 }
39745 
39746 static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
39747 {
39748         USE_OPLINE
39749         zend_free_op free_op_data2, free_op_data1;
39750         zval **var_ptr;
39751         zval *value;
39752 
39753         SAVE_OPLINE();
39754         switch (opline->extended_value) {
39755                 case ZEND_ASSIGN_OBJ:
39756                         return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39757                         break;
39758                 case ZEND_ASSIGN_DIM: {
39759                                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
39760 
39761                                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
39762                                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
39763                                 } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
39764                                         if (IS_CV == IS_VAR && !0) {
39765                                                 Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
39766                                         }
39767                                         return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39768                                 } else {
39769                                         zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
39770 
39771                                         zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
39772                                         value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
39773                                         var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
39774                                 }
39775                         }
39776                         break;
39777                 default:
39778                         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
39779                         var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
39780                         /* do nothing */
39781                         break;
39782         }
39783 
39784         if (UNEXPECTED(var_ptr == NULL)) {
39785                 zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
39786         }
39787 
39788         if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
39789                 if (RETURN_VALUE_USED(opline)) {
39790                         PZVAL_LOCK(&EG(uninitialized_zval));
39791                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
39792                 }
39793 
39794 
39795                 CHECK_EXCEPTION();
39796                 if (opline->extended_value == ZEND_ASSIGN_DIM) {
39797                         ZEND_VM_INC_OPCODE();
39798                 }
39799                 ZEND_VM_NEXT_OPCODE();
39800         }
39801 
39802         SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
39803 
39804         if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
39805            && Z_OBJ_HANDLER_PP(var_ptr, get)
39806            && Z_OBJ_HANDLER_PP(var_ptr, set)) {
39807                 /* proxy object */
39808                 zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
39809                 Z_ADDREF_P(objval);
39810                 binary_op(objval, objval, value TSRMLS_CC);
39811                 Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
39812                 zval_ptr_dtor(&objval);
39813         } else {
39814                 binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
39815         }
39816 
39817         if (RETURN_VALUE_USED(opline)) {
39818                 PZVAL_LOCK(*var_ptr);
39819                 EX_T(opline->result.var).var.ptr = *var_ptr;
39820         }
39821 
39822         if (opline->extended_value == ZEND_ASSIGN_DIM) {
39823                 FREE_OP(free_op_data1);
39824                 FREE_OP_VAR_PTR(free_op_data2);
39825 
39826                 CHECK_EXCEPTION();
39827                 ZEND_VM_INC_OPCODE();
39828         } else {
39829 
39830                 CHECK_EXCEPTION();
39831         }
39832         ZEND_VM_NEXT_OPCODE();
39833 }
39834 
39835 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39836 {
39837         return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39838 }
39839 
39840 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39841 {
39842         return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39843 }
39844 
39845 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39846 {
39847         return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39848 }
39849 
39850 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39851 {
39852         return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39853 }
39854 
39855 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39856 {
39857         return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39858 }
39859 
39860 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39861 {
39862         return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39863 }
39864 
39865 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39866 {
39867         return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39868 }
39869 
39870 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39871 {
39872         return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39873 }
39874 
39875 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39876 {
39877         return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39878 }
39879 
39880 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39881 {
39882         return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39883 }
39884 
39885 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39886 {
39887         return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39888 }
39889 
39890 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
39891 {
39892         USE_OPLINE
39893 
39894         zval **object_ptr;
39895         zval *object;
39896         zval *property;
39897         zval **retval;
39898         int have_get_ptr = 0;
39899 
39900         SAVE_OPLINE();
39901         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
39902         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
39903         retval = &EX_T(opline->result.var).var.ptr;
39904 
39905         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
39906                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
39907         }
39908 
39909         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
39910         object = *object_ptr;
39911 
39912         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39913                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
39914 
39915                 if (RETURN_VALUE_USED(opline)) {
39916                         PZVAL_LOCK(&EG(uninitialized_zval));
39917                         *retval = &EG(uninitialized_zval);
39918                 }
39919 
39920                 CHECK_EXCEPTION();
39921                 ZEND_VM_NEXT_OPCODE();
39922         }
39923 
39924         /* here we are sure we are dealing with an object */
39925 
39926         if (0) {
39927                 MAKE_REAL_ZVAL_PTR(property);
39928         }
39929 
39930         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
39931                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39932                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
39933                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
39934 
39935                         have_get_ptr = 1;
39936                         incdec_op(*zptr);
39937                         if (RETURN_VALUE_USED(opline)) {
39938                                 *retval = *zptr;
39939                                 PZVAL_LOCK(*retval);
39940                         }
39941                 }
39942         }
39943 
39944         if (!have_get_ptr) {
39945                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
39946                         zval *z;
39947 
39948                         Z_ADDREF_P(object);
39949                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39950 
39951                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
39952                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
39953 
39954                                 if (Z_REFCOUNT_P(z) == 0) {
39955                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
39956                                         zval_dtor(z);
39957                                         FREE_ZVAL(z);
39958                                 }
39959                                 z = value;
39960                         }
39961                         Z_ADDREF_P(z);
39962                         SEPARATE_ZVAL_IF_NOT_REF(&z);
39963                         incdec_op(z);
39964                         *retval = z;
39965                         Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
39966                         zval_ptr_dtor(&object);
39967                         SELECTIVE_PZVAL_LOCK(*retval, opline);
39968                         zval_ptr_dtor(&z);
39969                 } else {
39970                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
39971                         if (RETURN_VALUE_USED(opline)) {
39972                                 PZVAL_LOCK(&EG(uninitialized_zval));
39973                                 *retval = &EG(uninitialized_zval);
39974                         }
39975                 }
39976         }
39977 
39978         if (0) {
39979                 zval_ptr_dtor(&property);
39980         } else {
39981 
39982         }
39983 
39984         CHECK_EXCEPTION();
39985         ZEND_VM_NEXT_OPCODE();
39986 }
39987 
39988 static int ZEND_FASTCALL  ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39989 {
39990         return zend_pre_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39991 }
39992 
39993 static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39994 {
39995         return zend_pre_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
39996 }
39997 
39998 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
39999 {
40000         USE_OPLINE
40001 
40002         zval **object_ptr;
40003         zval *object;
40004         zval *property;
40005         zval *retval;
40006         int have_get_ptr = 0;
40007 
40008         SAVE_OPLINE();
40009         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40010         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40011         retval = &EX_T(opline->result.var).tmp_var;
40012 
40013         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
40014                 zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
40015         }
40016 
40017         make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
40018         object = *object_ptr;
40019 
40020         if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
40021                 zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
40022 
40023                 ZVAL_NULL(retval);
40024 
40025                 CHECK_EXCEPTION();
40026                 ZEND_VM_NEXT_OPCODE();
40027         }
40028 
40029         /* here we are sure we are dealing with an object */
40030 
40031         if (0) {
40032                 MAKE_REAL_ZVAL_PTR(property);
40033         }
40034 
40035         if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
40036                 zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40037                 if (zptr != NULL) {                     /* NULL means no success in getting PTR */
40038                         have_get_ptr = 1;
40039                         SEPARATE_ZVAL_IF_NOT_REF(zptr);
40040 
40041                         ZVAL_COPY_VALUE(retval, *zptr);
40042                         zendi_zval_copy_ctor(*retval);
40043 
40044                         incdec_op(*zptr);
40045 
40046                 }
40047         }
40048 
40049         if (!have_get_ptr) {
40050                 if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
40051                         zval *z, *z_copy;
40052 
40053                         Z_ADDREF_P(object);
40054                         z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40055                         if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
40056                                 zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
40057 
40058                                 if (Z_REFCOUNT_P(z) == 0) {
40059                                         GC_REMOVE_ZVAL_FROM_BUFFER(z);
40060                                         zval_dtor(z);
40061                                         FREE_ZVAL(z);
40062                                 }
40063                                 z = value;
40064                         }
40065                         ZVAL_COPY_VALUE(retval, z);
40066                         zendi_zval_copy_ctor(*retval);
40067                         ALLOC_ZVAL(z_copy);
40068                         INIT_PZVAL_COPY(z_copy, z);
40069                         zendi_zval_copy_ctor(*z_copy);
40070                         incdec_op(z_copy);
40071                         Z_ADDREF_P(z);
40072                         Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40073                         zval_ptr_dtor(&object);
40074                         zval_ptr_dtor(&z_copy);
40075                         zval_ptr_dtor(&z);
40076                 } else {
40077                         zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
40078                         ZVAL_NULL(retval);
40079                 }
40080         }
40081 
40082         if (0) {
40083                 zval_ptr_dtor(&property);
40084         } else {
40085 
40086         }
40087 
40088         CHECK_EXCEPTION();
40089         ZEND_VM_NEXT_OPCODE();
40090 }
40091 
40092 static int ZEND_FASTCALL  ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40093 {
40094         return zend_post_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40095 }
40096 
40097 static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40098 {
40099         return zend_post_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40100 }
40101 
40102 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40103 {
40104         USE_OPLINE
40105 
40106         zval *container;
40107 
40108         SAVE_OPLINE();
40109         container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
40110         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
40111 
40112         if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
40113 
40114         }
40115         CHECK_EXCEPTION();
40116         ZEND_VM_NEXT_OPCODE();
40117 }
40118 
40119 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40120 {
40121         USE_OPLINE
40122         zend_free_op free_op1;
40123         zval **container;
40124 
40125         SAVE_OPLINE();
40126         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40127 
40128         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40129                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40130         }
40131         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
40132 
40133         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40134                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40135         }
40136 
40137         /* We are going to assign the result by reference */
40138         if (UNEXPECTED(opline->extended_value != 0)) {
40139                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
40140 
40141                 if (retval_ptr) {
40142                         Z_DELREF_PP(retval_ptr);
40143                         SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
40144                         Z_ADDREF_PP(retval_ptr);
40145                 }
40146         }
40147 
40148         CHECK_EXCEPTION();
40149         ZEND_VM_NEXT_OPCODE();
40150 }
40151 
40152 static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40153 {
40154         USE_OPLINE
40155         zend_free_op free_op1;
40156         zval **container;
40157 
40158         SAVE_OPLINE();
40159         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40160 
40161         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40162                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40163         }
40164         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
40165 
40166         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40167                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40168         }
40169 
40170         CHECK_EXCEPTION();
40171         ZEND_VM_NEXT_OPCODE();
40172 }
40173 
40174 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40175 {
40176         USE_OPLINE
40177 
40178         zval *container;
40179 
40180         SAVE_OPLINE();
40181         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
40182         zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC);
40183 
40184 
40185         CHECK_EXCEPTION();
40186         ZEND_VM_NEXT_OPCODE();
40187 }
40188 
40189 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40190 {
40191         USE_OPLINE
40192         zend_free_op free_op1;
40193 
40194         SAVE_OPLINE();
40195 
40196         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
40197                 zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40198                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40199                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40200                 }
40201                 zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
40202                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40203                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40204                 }
40205 
40206 
40207         } else {
40208                 zval *container;
40209 
40210                 if (IS_CV == IS_UNUSED) {
40211                         zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
40212                 }
40213                 container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
40214                 zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
40215 
40216 
40217         }
40218         CHECK_EXCEPTION();
40219         ZEND_VM_NEXT_OPCODE();
40220 }
40221 
40222 static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40223 {
40224         USE_OPLINE
40225         zend_free_op free_op1;
40226         zval **container;
40227 
40228         SAVE_OPLINE();
40229         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
40230 
40231         if (IS_CV == IS_CV) {
40232                 if (container != &EG(uninitialized_zval_ptr)) {
40233                         SEPARATE_ZVAL_IF_NOT_REF(container);
40234                 }
40235         }
40236         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40237                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40238         }
40239         zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC);
40240 
40241         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40242                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40243         }
40244 
40245         if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
40246                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
40247                 ZEND_VM_NEXT_OPCODE();
40248         } else {
40249                 zend_free_op free_res;
40250                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
40251 
40252                 PZVAL_UNLOCK(*retval_ptr, &free_res);
40253                 if (retval_ptr != &EG(uninitialized_zval_ptr)) {
40254                         SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
40255                 }
40256                 PZVAL_LOCK(*retval_ptr);
40257                 FREE_OP_VAR_PTR(free_res);
40258                 CHECK_EXCEPTION();
40259                 ZEND_VM_NEXT_OPCODE();
40260         }
40261 }
40262 
40263 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS)
40264 {
40265         USE_OPLINE
40266 
40267         zval *container;
40268 
40269         zval *offset;
40270 
40271         SAVE_OPLINE();
40272         container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
40273         offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40274 
40275         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
40276             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
40277                 zend_error(E_NOTICE, "Trying to get property of non-object");
40278                 PZVAL_LOCK(&EG(uninitialized_zval));
40279                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40280 
40281         } else {
40282                 zval *retval;
40283 
40284                 if (0) {
40285                         MAKE_REAL_ZVAL_PTR(offset);
40286                 }
40287 
40288                 /* here we are sure we are dealing with an object */
40289                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40290 
40291                 PZVAL_LOCK(retval);
40292                 EX_T(opline->result.var).var.ptr = retval;
40293 
40294                 if (0) {
40295                         zval_ptr_dtor(&offset);
40296                 } else {
40297 
40298                 }
40299         }
40300 
40301         CHECK_EXCEPTION();
40302         ZEND_VM_NEXT_OPCODE();
40303 }
40304 
40305 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40306 {
40307         return zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40308 }
40309 
40310 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40311 {
40312         USE_OPLINE
40313         zend_free_op free_op1;
40314         zval *property;
40315         zval **container;
40316 
40317         SAVE_OPLINE();
40318         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40319 
40320         if (0) {
40321                 MAKE_REAL_ZVAL_PTR(property);
40322         }
40323         container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40324         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40325                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
40326         }
40327 
40328         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
40329         if (0) {
40330                 zval_ptr_dtor(&property);
40331         } else {
40332 
40333         }
40334         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40335                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40336         }
40337 
40338         /* We are going to assign the result by reference */
40339         if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
40340                 zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
40341 
40342                 Z_DELREF_PP(retval_ptr);
40343                 SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
40344                 Z_ADDREF_PP(retval_ptr);
40345                 EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
40346                 EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
40347         }
40348 
40349         CHECK_EXCEPTION();
40350         ZEND_VM_NEXT_OPCODE();
40351 }
40352 
40353 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40354 {
40355         USE_OPLINE
40356         zend_free_op free_op1;
40357         zval *property;
40358         zval **container;
40359 
40360         SAVE_OPLINE();
40361         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40362         container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
40363 
40364         if (0) {
40365                 MAKE_REAL_ZVAL_PTR(property);
40366         }
40367         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40368                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
40369         }
40370         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
40371         if (0) {
40372                 zval_ptr_dtor(&property);
40373         } else {
40374 
40375         }
40376         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40377                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40378         }
40379 
40380         CHECK_EXCEPTION();
40381         ZEND_VM_NEXT_OPCODE();
40382 }
40383 
40384 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40385 {
40386         USE_OPLINE
40387 
40388         zval *container;
40389 
40390         zval *offset;
40391 
40392         SAVE_OPLINE();
40393         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
40394         offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40395 
40396         if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
40397             UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
40398                 PZVAL_LOCK(&EG(uninitialized_zval));
40399                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40400 
40401         } else {
40402                 zval *retval;
40403 
40404                 if (0) {
40405                         MAKE_REAL_ZVAL_PTR(offset);
40406                 }
40407 
40408                 /* here we are sure we are dealing with an object */
40409                 retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40410 
40411                 PZVAL_LOCK(retval);
40412                 EX_T(opline->result.var).var.ptr = retval;
40413 
40414                 if (0) {
40415                         zval_ptr_dtor(&offset);
40416                 } else {
40417 
40418                 }
40419         }
40420 
40421         CHECK_EXCEPTION();
40422         ZEND_VM_NEXT_OPCODE();
40423 }
40424 
40425 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40426 {
40427         USE_OPLINE
40428 
40429         if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
40430                 /* Behave like FETCH_OBJ_W */
40431                 zend_free_op free_op1;
40432                 zval *property;
40433                 zval **container;
40434 
40435                 SAVE_OPLINE();
40436                 property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40437                 container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40438 
40439                 if (0) {
40440                         MAKE_REAL_ZVAL_PTR(property);
40441                 }
40442                 if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40443                         zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
40444                 }
40445                 zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
40446                 if (0) {
40447                         zval_ptr_dtor(&property);
40448                 } else {
40449 
40450                 }
40451                 if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40452                         EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40453                 }
40454 
40455                 CHECK_EXCEPTION();
40456                 ZEND_VM_NEXT_OPCODE();
40457         } else {
40458                 return zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40459         }
40460 }
40461 
40462 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40463 {
40464         USE_OPLINE
40465         zend_free_op free_op1, free_res;
40466         zval **container;
40467         zval *property;
40468 
40469         SAVE_OPLINE();
40470         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
40471         property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40472 
40473         if (IS_CV == IS_CV) {
40474                 if (container != &EG(uninitialized_zval_ptr)) {
40475                         SEPARATE_ZVAL_IF_NOT_REF(container);
40476                 }
40477         }
40478         if (0) {
40479                 MAKE_REAL_ZVAL_PTR(property);
40480         }
40481         if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
40482                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
40483         }
40484         zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
40485         if (0) {
40486                 zval_ptr_dtor(&property);
40487         } else {
40488 
40489         }
40490         if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
40491                 EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
40492         }
40493 
40494         PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
40495         if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
40496                 SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
40497         }
40498         PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
40499         FREE_OP_VAR_PTR(free_res);
40500         CHECK_EXCEPTION();
40501         ZEND_VM_NEXT_OPCODE();
40502 }
40503 
40504 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40505 {
40506         USE_OPLINE
40507 
40508         zval **object_ptr;
40509         zval *property_name;
40510 
40511         SAVE_OPLINE();
40512         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40513         property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40514 
40515         if (0) {
40516                 MAKE_REAL_ZVAL_PTR(property_name);
40517         }
40518         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
40519                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40520         }
40521         zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40522         if (0) {
40523                 zval_ptr_dtor(&property_name);
40524         } else {
40525 
40526         }
40527 
40528         /* assign_obj has two opcodes! */
40529         CHECK_EXCEPTION();
40530         ZEND_VM_INC_OPCODE();
40531         ZEND_VM_NEXT_OPCODE();
40532 }
40533 
40534 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40535 {
40536         USE_OPLINE
40537 
40538         zval **object_ptr;
40539 
40540         SAVE_OPLINE();
40541         object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40542 
40543         if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
40544                 zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
40545         }
40546         if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
40547 
40548                 zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40549 
40550                 if (0) {
40551                         MAKE_REAL_ZVAL_PTR(property_name);
40552                 }
40553                 zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
40554                 if (0) {
40555                         zval_ptr_dtor(&property_name);
40556                 } else {
40557 
40558                 }
40559         } else {
40560                 zend_free_op free_op_data1, free_op_data2;
40561                 zval *value;
40562                 zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40563                 zval **variable_ptr_ptr;
40564 
40565                 zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC);
40566 
40567                 value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
40568                 variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
40569                 if (UNEXPECTED(variable_ptr_ptr == NULL)) {
40570                         if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
40571                                 if (RETURN_VALUE_USED(opline)) {
40572                                         zval *retval;
40573 
40574                                         ALLOC_ZVAL(retval);
40575                                         ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
40576                                         INIT_PZVAL(retval);
40577                                         EX_T(opline->result.var).var.ptr = retval;
40578                                 }
40579                         } else if (RETURN_VALUE_USED(opline)) {
40580                                 PZVAL_LOCK(&EG(uninitialized_zval));
40581                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40582                         }
40583                 } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
40584                         if (IS_TMP_FREE(free_op_data1)) {
40585                                 zval_dtor(value);
40586                         }
40587                         if (RETURN_VALUE_USED(opline)) {
40588                                 PZVAL_LOCK(&EG(uninitialized_zval));
40589                                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40590                         }
40591                 } else {
40592                         if ((opline+1)->op1_type == IS_TMP_VAR) {
40593                                 value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40594                         } else if ((opline+1)->op1_type == IS_CONST) {
40595                                 value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40596                         } else {
40597                                 value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40598                         }
40599                         if (RETURN_VALUE_USED(opline)) {
40600                                 PZVAL_LOCK(value);
40601                                 EX_T(opline->result.var).var.ptr = value;
40602                         }
40603                 }
40604                 FREE_OP_VAR_PTR(free_op_data2);
40605                 FREE_OP_IF_VAR(free_op_data1);
40606         }
40607 
40608         /* assign_dim has two opcodes! */
40609         CHECK_EXCEPTION();
40610         ZEND_VM_INC_OPCODE();
40611         ZEND_VM_NEXT_OPCODE();
40612 }
40613 
40614 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40615 {
40616         USE_OPLINE
40617 
40618         zval *value;
40619         zval **variable_ptr_ptr;
40620 
40621         SAVE_OPLINE();
40622         value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40623         variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40624 
40625         if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
40626                 if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) {
40627                         if (RETURN_VALUE_USED(opline)) {
40628                                 zval *retval;
40629 
40630                                 ALLOC_ZVAL(retval);
40631                                 ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
40632                                 INIT_PZVAL(retval);
40633                                 EX_T(opline->result.var).var.ptr = retval;
40634                         }
40635                 } else if (RETURN_VALUE_USED(opline)) {
40636                         PZVAL_LOCK(&EG(uninitialized_zval));
40637                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40638                 }
40639         } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
40640                 if (0) {
40641                         zval_dtor(value);
40642                 }
40643                 if (RETURN_VALUE_USED(opline)) {
40644                         PZVAL_LOCK(&EG(uninitialized_zval));
40645                         EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
40646                 }
40647         } else {
40648                 if (IS_CV == IS_TMP_VAR) {
40649                         value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40650                 } else if (IS_CV == IS_CONST) {
40651                         value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40652                 } else {
40653                         value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
40654                 }
40655                 if (RETURN_VALUE_USED(opline)) {
40656                         PZVAL_LOCK(value);
40657                         EX_T(opline->result.var).var.ptr = value;
40658                 }
40659         }
40660 
40661         if (IS_CV == IS_VAR && 0) {
40662                 zval_ptr_dtor_nogc(&value);
40663         }
40664 
40665         /* zend_assign_to_variable() always takes care of op2, never free it! */
40666 
40667         CHECK_EXCEPTION();
40668         ZEND_VM_NEXT_OPCODE();
40669 }
40670 
40671 static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40672 {
40673         USE_OPLINE
40674         zend_free_op free_op2;
40675         zval **variable_ptr_ptr;
40676         zval **value_ptr_ptr;
40677 
40678         SAVE_OPLINE();
40679         value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC);
40680 
40681         if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
40682                 zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
40683         }
40684 
40685         if (IS_CV == IS_VAR &&
40686             value_ptr_ptr &&
40687             !Z_ISREF_PP(value_ptr_ptr) &&
40688             opline->extended_value == ZEND_RETURNS_FUNCTION &&
40689             !EX_T(opline->op2.var).var.fcall_returned_reference) {
40690                 if (free_op2.var == NULL) {
40691                         PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
40692                 }
40693                 zend_error(E_STRICT, "Only variables should be assigned by reference");
40694                 if (UNEXPECTED(EG(exception) != NULL)) {
40695 
40696                         HANDLE_EXCEPTION();
40697                 }
40698                 return ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40699         } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
40700                 PZVAL_LOCK(*value_ptr_ptr);
40701         }
40702 
40703         variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40704         if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
40705             (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
40706                 zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
40707         }
40708         zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
40709 
40710         if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
40711                 Z_DELREF_PP(variable_ptr_ptr);
40712         }
40713 
40714         if (RETURN_VALUE_USED(opline)) {
40715                 PZVAL_LOCK(*variable_ptr_ptr);
40716                 EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
40717         }
40718 
40719 
40720         CHECK_EXCEPTION();
40721         ZEND_VM_NEXT_OPCODE();
40722 }
40723 
40724 static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40725 {
40726         USE_OPLINE
40727         zval *function_name;
40728         char *function_name_strval;
40729         int function_name_strlen;
40730 
40731         call_slot *call = EX(call_slots) + opline->result.num;
40732 
40733         SAVE_OPLINE();
40734 
40735         function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40736 
40737         if (IS_CV != IS_CONST &&
40738             UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
40739                 if (UNEXPECTED(EG(exception) != NULL)) {
40740                         HANDLE_EXCEPTION();
40741                 }
40742                 zend_error_noreturn(E_ERROR, "Method name must be a string");
40743         }
40744 
40745         function_name_strval = Z_STRVAL_P(function_name);
40746         function_name_strlen = Z_STRLEN_P(function_name);
40747 
40748         call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
40749 
40750         if (EXPECTED(call->object != NULL) &&
40751             EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
40752                 call->called_scope = Z_OBJCE_P(call->object);
40753 
40754                 if (IS_CV != IS_CONST ||
40755                     (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
40756                     zval *object = call->object;
40757 
40758                         if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
40759                                 zend_error_noreturn(E_ERROR, "Object does not support method calls");
40760                         }
40761 
40762                         /* First, locate the function. */
40763                         call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
40764                         if (UNEXPECTED(call->fbc == NULL)) {
40765                                 zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
40766                         }
40767                         if (IS_CV == IS_CONST &&
40768                             EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
40769                             EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
40770                             EXPECTED(call->object == object)) {
40771                                 CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
40772                         }
40773                 }
40774         } else {
40775                 if (UNEXPECTED(EG(exception) != NULL)) {
40776 
40777                         HANDLE_EXCEPTION();
40778                 }
40779                 zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
40780         }
40781 
40782         if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
40783                 call->object = NULL;
40784         } else {
40785                 if (!PZVAL_IS_REF(call->object)) {
40786                         Z_ADDREF_P(call->object); /* For $this pointer */
40787                 } else {
40788                         zval *this_ptr;
40789                         ALLOC_ZVAL(this_ptr);
40790                         INIT_PZVAL_COPY(this_ptr, call->object);
40791                         zval_copy_ctor(this_ptr);
40792                         call->object = this_ptr;
40793                 }
40794         }
40795 
40796         call->num_additional_args = 0;
40797         call->is_ctor_call = 0;
40798         EX(call) = call;
40799 
40800 
40801         CHECK_EXCEPTION();
40802         ZEND_VM_NEXT_OPCODE();
40803 }
40804 
40805 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40806 {
40807         USE_OPLINE
40808 
40809 
40810         SAVE_OPLINE();
40811         is_equal_function(&EX_T(opline->result.var).tmp_var,
40812                                  _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
40813                                  _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
40814 
40815         CHECK_EXCEPTION();
40816         ZEND_VM_NEXT_OPCODE();
40817 }
40818 
40819 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40820 {
40821         USE_OPLINE
40822 
40823         zval *expr_ptr;
40824 
40825         SAVE_OPLINE();
40826         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
40827                 zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
40828 
40829                 if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
40830                         zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
40831                 }
40832                 SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
40833                 expr_ptr = *expr_ptr_ptr;
40834                 Z_ADDREF_P(expr_ptr);
40835         } else {
40836                 expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
40837                 if (0) { /* temporary variable */
40838                         zval *new_expr;
40839 
40840                         ALLOC_ZVAL(new_expr);
40841                         INIT_PZVAL_COPY(new_expr, expr_ptr);
40842                         expr_ptr = new_expr;
40843                 } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
40844                         zval *new_expr;
40845 
40846                         ALLOC_ZVAL(new_expr);
40847                         INIT_PZVAL_COPY(new_expr, expr_ptr);
40848                         expr_ptr = new_expr;
40849                         zendi_zval_copy_ctor(*expr_ptr);
40850 
40851                 } else if (IS_CV == IS_CV) {
40852                         Z_ADDREF_P(expr_ptr);
40853                 }
40854         }
40855 
40856         if (IS_CV != IS_UNUSED) {
40857 
40858                 zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40859                 ulong hval;
40860 
40861                 switch (Z_TYPE_P(offset)) {
40862                         case IS_DOUBLE:
40863                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
40864                                 goto num_index;
40865                         case IS_LONG:
40866                         case IS_BOOL:
40867                                 hval = Z_LVAL_P(offset);
40868 num_index:
40869                                 zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
40870                                 break;
40871                         case IS_STRING:
40872                                 if (IS_CV == IS_CONST) {
40873                                         hval = Z_HASH_P(offset);
40874                                 } else {
40875                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
40876                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
40877                                 }
40878                                 zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
40879                                 break;
40880                         case IS_NULL:
40881                                 zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
40882                                 break;
40883                         default:
40884                                 zend_error(E_WARNING, "Illegal offset type");
40885                                 zval_ptr_dtor(&expr_ptr);
40886                                 /* do nothing */
40887                                 break;
40888                 }
40889 
40890         } else {
40891                 zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
40892         }
40893         if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
40894 
40895         }
40896         CHECK_EXCEPTION();
40897         ZEND_VM_NEXT_OPCODE();
40898 }
40899 
40900 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40901 {
40902         USE_OPLINE
40903 
40904         array_init(&EX_T(opline->result.var).tmp_var);
40905         if (IS_CV == IS_UNUSED) {
40906                 ZEND_VM_NEXT_OPCODE();
40907 #if 0 || IS_CV != IS_UNUSED
40908         } else {
40909                 return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
40910 #endif
40911         }
40912 }
40913 
40914 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40915 {
40916         USE_OPLINE
40917 
40918         zval **container;
40919         zval *offset;
40920         ulong hval;
40921 
40922         SAVE_OPLINE();
40923         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
40924         if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
40925                 SEPARATE_ZVAL_IF_NOT_REF(container);
40926         }
40927         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
40928 
40929         if (IS_CV != IS_VAR || container) {
40930                 switch (Z_TYPE_PP(container)) {
40931                         case IS_ARRAY: {
40932                                 HashTable *ht = Z_ARRVAL_PP(container);
40933 
40934                                 switch (Z_TYPE_P(offset)) {
40935                                         case IS_DOUBLE:
40936                                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
40937                                                 zend_hash_index_del(ht, hval);
40938                                                 break;
40939                                         case IS_RESOURCE:
40940                                         case IS_BOOL:
40941                                         case IS_LONG:
40942                                                 hval = Z_LVAL_P(offset);
40943                                                 zend_hash_index_del(ht, hval);
40944                                                 break;
40945                                         case IS_STRING:
40946                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
40947                                                         Z_ADDREF_P(offset);
40948                                                 }
40949                                                 if (IS_CV == IS_CONST) {
40950                                                         hval = Z_HASH_P(offset);
40951                                                 } else {
40952                                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
40953                                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
40954                                                 }
40955                                                 if (ht == &EG(symbol_table)) {
40956                                                         zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
40957                                                 } else {
40958                                                         zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
40959                                                 }
40960                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
40961                                                         zval_ptr_dtor(&offset);
40962                                                 }
40963                                                 break;
40964 num_index_dim:
40965                                                 zend_hash_index_del(ht, hval);
40966                                                 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
40967                                                         zval_ptr_dtor(&offset);
40968                                                 }
40969                                                 break;
40970                                         case IS_NULL:
40971                                                 zend_hash_del(ht, "", sizeof(""));
40972                                                 break;
40973                                         default:
40974                                                 zend_error(E_WARNING, "Illegal offset type in unset");
40975                                                 break;
40976                                 }
40977 
40978                                 break;
40979                         }
40980                         case IS_OBJECT:
40981                                 if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
40982                                         zend_error_noreturn(E_ERROR, "Cannot use object as array");
40983                                 }
40984                                 if (0) {
40985                                         MAKE_REAL_ZVAL_PTR(offset);
40986                                 }
40987                                 Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
40988                                 if (0) {
40989                                         zval_ptr_dtor(&offset);
40990                                 } else {
40991 
40992                                 }
40993                                 break;
40994                         case IS_STRING:
40995                                 zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
40996                                 ZEND_VM_CONTINUE(); /* bailed out before */
40997                         default:
40998 
40999                                 break;
41000                 }
41001         } else {
41002 
41003         }
41004 
41005         CHECK_EXCEPTION();
41006         ZEND_VM_NEXT_OPCODE();
41007 }
41008 
41009 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41010 {
41011         USE_OPLINE
41012 
41013         zval **container;
41014         zval *offset;
41015 
41016         SAVE_OPLINE();
41017         container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
41018         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41019 
41020         if (IS_CV != IS_VAR || container) {
41021                 if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
41022                         SEPARATE_ZVAL_IF_NOT_REF(container);
41023                 }
41024                 if (Z_TYPE_PP(container) == IS_OBJECT) {
41025                         if (0) {
41026                                 MAKE_REAL_ZVAL_PTR(offset);
41027                         }
41028                         if (Z_OBJ_HT_P(*container)->unset_property) {
41029                                 Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
41030                         } else {
41031                                 zend_error(E_NOTICE, "Trying to unset property of non-object");
41032                         }
41033                         if (0) {
41034                                 zval_ptr_dtor(&offset);
41035                         } else {
41036 
41037                         }
41038                 } else {
41039 
41040                 }
41041         } else {
41042 
41043         }
41044 
41045         CHECK_EXCEPTION();
41046         ZEND_VM_NEXT_OPCODE();
41047 }
41048 
41049 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
41050 {
41051         USE_OPLINE
41052 
41053         zval *container;
41054         zval **value = NULL;
41055         int result = 0;
41056         ulong hval;
41057         zval *offset;
41058 
41059         SAVE_OPLINE();
41060         container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
41061         offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41062 
41063         if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
41064                 HashTable *ht;
41065                 int isset = 0;
41066 
41067                 ht = Z_ARRVAL_P(container);
41068 
41069                 switch (Z_TYPE_P(offset)) {
41070                         case IS_DOUBLE:
41071                                 hval = zend_dval_to_lval(Z_DVAL_P(offset));
41072                                 goto num_index_prop;
41073                         case IS_RESOURCE:
41074                         case IS_BOOL:
41075                         case IS_LONG:
41076                                 hval = Z_LVAL_P(offset);
41077 num_index_prop:
41078                                 if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
41079                                         isset = 1;
41080                                 }
41081                                 break;
41082                         case IS_STRING:
41083                                 if (IS_CV == IS_CONST) {
41084                                         hval = Z_HASH_P(offset);
41085                                 } else {
41086                                         ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
41087                                         hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
41088                                 }
41089                                 if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
41090                                         isset = 1;
41091                                 }
41092                                 break;
41093                         case IS_NULL:
41094                                 if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
41095                                         isset = 1;
41096                                 }
41097                                 break;
41098                         default:
41099                                 zend_error(E_WARNING, "Illegal offset type in isset or empty");
41100                                 break;
41101                 }
41102 
41103                 if (opline->extended_value & ZEND_ISSET) {
41104                         if (isset && Z_TYPE_PP(value) == IS_NULL) {
41105                                 result = 0;
41106                         } else {
41107                                 result = isset;
41108                         }
41109                 } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
41110                         if (!isset || !i_zend_is_true(*value)) {
41111                                 result = 0;
41112                         } else {
41113                                 result = 1;
41114                         }
41115                 }
41116 
41117         } else if (Z_TYPE_P(container) == IS_OBJECT) {
41118                 if (0) {
41119                         MAKE_REAL_ZVAL_PTR(offset);
41120                 }
41121                 if (prop_dim) {
41122                         if (Z_OBJ_HT_P(container)->has_property) {
41123                                 result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
41124                         } else {
41125                                 zend_error(E_NOTICE, "Trying to check property of non-object");
41126                                 result = 0;
41127                         }
41128                 } else {
41129                         if (Z_OBJ_HT_P(container)->has_dimension) {
41130                                 result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
41131                         } else {
41132                                 zend_error(E_NOTICE, "Trying to check element of non-array");
41133                                 result = 0;
41134                         }
41135                 }
41136                 if (0) {
41137                         zval_ptr_dtor(&offset);
41138                 } else {
41139 
41140                 }
41141         } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
41142                 zval tmp;
41143 
41144                 if (Z_TYPE_P(offset) != IS_LONG) {
41145                         if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
41146                                         || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
41147                                                 && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
41148                                 ZVAL_COPY_VALUE(&tmp, offset);
41149                                 zval_copy_ctor(&tmp);
41150                                 convert_to_long(&tmp);
41151                                 offset = &tmp;
41152                         } else {
41153                                 /* can not be converted to proper offset, return "not set" */
41154                                 result = 0;
41155                         }
41156                 }
41157                 if (Z_TYPE_P(offset) == IS_LONG) {
41158                         if (opline->extended_value & ZEND_ISSET) {
41159                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
41160                                         result = 1;
41161                                 }
41162                         } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
41163                                 if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
41164                                         result = 1;
41165                                 }
41166                         }
41167                 }
41168 
41169         } else {
41170 
41171         }
41172 
41173         Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
41174         if (opline->extended_value & ZEND_ISSET) {
41175                 Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
41176         } else {
41177                 Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
41178         }
41179 
41180         CHECK_EXCEPTION();
41181         ZEND_VM_NEXT_OPCODE();
41182 }
41183 
41184 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41185 {
41186         return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
41187 }
41188 
41189 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41190 {
41191         return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
41192 }
41193 
41194 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41195 {
41196         USE_OPLINE
41197 
41198         /* The generator object is stored in return_value_ptr_ptr */
41199         zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
41200 
41201         if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
41202                 zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
41203         }
41204 
41205         /* Destroy the previously yielded value */
41206         if (generator->value) {
41207                 zval_ptr_dtor(&generator->value);
41208         }
41209 
41210         /* Destroy the previously yielded key */
41211         if (generator->key) {
41212                 zval_ptr_dtor(&generator->key);
41213         }
41214 
41215         /* Set the new yielded value */
41216         if (IS_CV != IS_UNUSED) {
41217 
41218 
41219                 if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
41220                         /* Constants and temporary variables aren't yieldable by reference,
41221                          * but we still allow them with a notice. */
41222                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
41223                                 zval *value, *copy;
41224 
41225                                 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
41226 
41227                                 value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
41228                                 ALLOC_ZVAL(copy);
41229                                 INIT_PZVAL_COPY(copy, value);
41230 
41231                                 /* Temporary variables don't need ctor copying */
41232                                 if (!0) {
41233                                         zval_copy_ctor(copy);
41234                                 }
41235 
41236                                 generator->value = copy;
41237                         } else {
41238                                 zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
41239 
41240                                 if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
41241                                         zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
41242                                 }
41243 
41244                                 /* If a function call result is yielded and the function did
41245                                  * not return by reference we throw a notice. */
41246                                 if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
41247                                     && !(opline->extended_value == ZEND_RETURNS_FUNCTION
41248                                          && EX_T(opline->op1.var).var.fcall_returned_reference)
41249                                     && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
41250                                         zend_error(E_NOTICE, "Only variable references should be yielded by reference");
41251 
41252                                         Z_ADDREF_PP(value_ptr);
41253                                         generator->value = *value_ptr;
41254                                 } else {
41255                                         SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
41256                                         Z_ADDREF_PP(value_ptr);
41257                                         generator->value = *value_ptr;
41258                                 }
41259 
41260                         }
41261                 } else {
41262                         zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
41263 
41264                         /* Consts, temporary variables and references need copying */
41265                         if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
41266                                 || PZVAL_IS_REF(value)
41267                         ) {
41268                                 zval *copy;
41269 
41270                                 ALLOC_ZVAL(copy);
41271                                 INIT_PZVAL_COPY(copy, value);
41272 
41273                                 /* Temporary variables don't need ctor copying */
41274                                 if (!0) {
41275                                         zval_copy_ctor(copy);
41276                                 }
41277 
41278                                 generator->value = copy;
41279 
41280                         } else {
41281                                 if (IS_CV == IS_CV) {
41282                                         Z_ADDREF_P(value);
41283                                 }
41284                                 generator->value = value;
41285                         }
41286                 }
41287         } else {
41288                 /* If no value was specified yield null */
41289                 Z_ADDREF(EG(uninitialized_zval));
41290                 generator->value = &EG(uninitialized_zval);
41291         }
41292 
41293         /* Set the new yielded key */
41294         if (IS_CV != IS_UNUSED) {
41295 
41296                 zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
41297 
41298                 /* Consts, temporary variables and references need copying */
41299                 if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
41300                         || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
41301                 ) {
41302                         zval *copy;
41303 
41304                         ALLOC_ZVAL(copy);
41305                         INIT_PZVAL_COPY(copy, key);
41306 
41307                         /* Temporary variables don't need ctor copying */
41308                         if (!0) {
41309                                 zval_copy_ctor(copy);
41310                         }
41311 
41312                         generator->key = copy;
41313                 } else {
41314                         Z_ADDREF_P(key);
41315                         generator->key = key;
41316                 }
41317 
41318                 if (Z_TYPE_P(generator->key) == IS_LONG
41319                     && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
41320                 ) {
41321                         generator->largest_used_integer_key = Z_LVAL_P(generator->key);
41322                 }
41323 
41324         } else {
41325                 /* If no key was specified we use auto-increment keys */
41326                 generator->largest_used_integer_key++;
41327 
41328                 ALLOC_INIT_ZVAL(generator->key);
41329                 ZVAL_LONG(generator->key, generator->largest_used_integer_key);
41330         }
41331 
41332         if (RETURN_VALUE_USED(opline)) {
41333                 /* If the return value of yield is used set the send
41334                  * target and initialize it to NULL */
41335                 generator->send_target = &EX_T(opline->result.var).var.ptr;
41336                 Z_ADDREF(EG(uninitialized_zval));
41337                 EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
41338         } else {
41339                 generator->send_target = NULL;
41340         }
41341 
41342         /* We increment to the next op, so we are at the correct position when the
41343          * generator is resumed. */
41344         ZEND_VM_INC_OPCODE();
41345 
41346         /* The GOTO VM uses a local opline variable. We need to set the opline
41347          * variable in execute_data so we don't resume at an old position. */
41348         SAVE_OPLINE();
41349 
41350         ZEND_VM_RETURN();
41351 }
41352 
41353 static int ZEND_FASTCALL  ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41354 {
41355         USE_OPLINE
41356 
41357 
41358         SAVE_OPLINE();
41359         pow_function(&EX_T(opline->result.var).tmp_var,
41360                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
41361                 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
41362 
41363 
41364         CHECK_EXCEPTION();
41365         ZEND_VM_NEXT_OPCODE();
41366 }
41367 
41368 static int ZEND_FASTCALL  ZEND_ASSIGN_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41369 {
41370         return zend_binary_assign_op_helper_SPEC_CV_CV(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
41371 }
41372 
41373 static int ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41374 {
41375         zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);
41376         ZEND_VM_NEXT_OPCODE(); /* Never reached */
41377 }
41378 
41379 
41380 void zend_init_opcodes_handlers(void)
41381 {
41382   static const opcode_handler_t labels[] = {
41383         ZEND_NOP_SPEC_HANDLER,
41384         ZEND_NOP_SPEC_HANDLER,
41385         ZEND_NOP_SPEC_HANDLER,
41386         ZEND_NOP_SPEC_HANDLER,
41387         ZEND_NOP_SPEC_HANDLER,
41388         ZEND_NOP_SPEC_HANDLER,
41389         ZEND_NOP_SPEC_HANDLER,
41390         ZEND_NOP_SPEC_HANDLER,
41391         ZEND_NOP_SPEC_HANDLER,
41392         ZEND_NOP_SPEC_HANDLER,
41393         ZEND_NOP_SPEC_HANDLER,
41394         ZEND_NOP_SPEC_HANDLER,
41395         ZEND_NOP_SPEC_HANDLER,
41396         ZEND_NOP_SPEC_HANDLER,
41397         ZEND_NOP_SPEC_HANDLER,
41398         ZEND_NOP_SPEC_HANDLER,
41399         ZEND_NOP_SPEC_HANDLER,
41400         ZEND_NOP_SPEC_HANDLER,
41401         ZEND_NOP_SPEC_HANDLER,
41402         ZEND_NOP_SPEC_HANDLER,
41403         ZEND_NOP_SPEC_HANDLER,
41404         ZEND_NOP_SPEC_HANDLER,
41405         ZEND_NOP_SPEC_HANDLER,
41406         ZEND_NOP_SPEC_HANDLER,
41407         ZEND_NOP_SPEC_HANDLER,
41408         ZEND_ADD_SPEC_CONST_CONST_HANDLER,
41409         ZEND_ADD_SPEC_CONST_TMP_HANDLER,
41410         ZEND_ADD_SPEC_CONST_VAR_HANDLER,
41411         ZEND_NULL_HANDLER,
41412         ZEND_ADD_SPEC_CONST_CV_HANDLER,
41413         ZEND_ADD_SPEC_TMP_CONST_HANDLER,
41414         ZEND_ADD_SPEC_TMP_TMP_HANDLER,
41415         ZEND_ADD_SPEC_TMP_VAR_HANDLER,
41416         ZEND_NULL_HANDLER,
41417         ZEND_ADD_SPEC_TMP_CV_HANDLER,
41418         ZEND_ADD_SPEC_VAR_CONST_HANDLER,
41419         ZEND_ADD_SPEC_VAR_TMP_HANDLER,
41420         ZEND_ADD_SPEC_VAR_VAR_HANDLER,
41421         ZEND_NULL_HANDLER,
41422         ZEND_ADD_SPEC_VAR_CV_HANDLER,
41423         ZEND_NULL_HANDLER,
41424         ZEND_NULL_HANDLER,
41425         ZEND_NULL_HANDLER,
41426         ZEND_NULL_HANDLER,
41427         ZEND_NULL_HANDLER,
41428         ZEND_ADD_SPEC_CV_CONST_HANDLER,
41429         ZEND_ADD_SPEC_CV_TMP_HANDLER,
41430         ZEND_ADD_SPEC_CV_VAR_HANDLER,
41431         ZEND_NULL_HANDLER,
41432         ZEND_ADD_SPEC_CV_CV_HANDLER,
41433         ZEND_SUB_SPEC_CONST_CONST_HANDLER,
41434         ZEND_SUB_SPEC_CONST_TMP_HANDLER,
41435         ZEND_SUB_SPEC_CONST_VAR_HANDLER,
41436         ZEND_NULL_HANDLER,
41437         ZEND_SUB_SPEC_CONST_CV_HANDLER,
41438         ZEND_SUB_SPEC_TMP_CONST_HANDLER,
41439         ZEND_SUB_SPEC_TMP_TMP_HANDLER,
41440         ZEND_SUB_SPEC_TMP_VAR_HANDLER,
41441         ZEND_NULL_HANDLER,
41442         ZEND_SUB_SPEC_TMP_CV_HANDLER,
41443         ZEND_SUB_SPEC_VAR_CONST_HANDLER,
41444         ZEND_SUB_SPEC_VAR_TMP_HANDLER,
41445         ZEND_SUB_SPEC_VAR_VAR_HANDLER,
41446         ZEND_NULL_HANDLER,
41447         ZEND_SUB_SPEC_VAR_CV_HANDLER,
41448         ZEND_NULL_HANDLER,
41449         ZEND_NULL_HANDLER,
41450         ZEND_NULL_HANDLER,
41451         ZEND_NULL_HANDLER,
41452         ZEND_NULL_HANDLER,
41453         ZEND_SUB_SPEC_CV_CONST_HANDLER,
41454         ZEND_SUB_SPEC_CV_TMP_HANDLER,
41455         ZEND_SUB_SPEC_CV_VAR_HANDLER,
41456         ZEND_NULL_HANDLER,
41457         ZEND_SUB_SPEC_CV_CV_HANDLER,
41458         ZEND_MUL_SPEC_CONST_CONST_HANDLER,
41459         ZEND_MUL_SPEC_CONST_TMP_HANDLER,
41460         ZEND_MUL_SPEC_CONST_VAR_HANDLER,
41461         ZEND_NULL_HANDLER,
41462         ZEND_MUL_SPEC_CONST_CV_HANDLER,
41463         ZEND_MUL_SPEC_TMP_CONST_HANDLER,
41464         ZEND_MUL_SPEC_TMP_TMP_HANDLER,
41465         ZEND_MUL_SPEC_TMP_VAR_HANDLER,
41466         ZEND_NULL_HANDLER,
41467         ZEND_MUL_SPEC_TMP_CV_HANDLER,
41468         ZEND_MUL_SPEC_VAR_CONST_HANDLER,
41469         ZEND_MUL_SPEC_VAR_TMP_HANDLER,
41470         ZEND_MUL_SPEC_VAR_VAR_HANDLER,
41471         ZEND_NULL_HANDLER,
41472         ZEND_MUL_SPEC_VAR_CV_HANDLER,
41473         ZEND_NULL_HANDLER,
41474         ZEND_NULL_HANDLER,
41475         ZEND_NULL_HANDLER,
41476         ZEND_NULL_HANDLER,
41477         ZEND_NULL_HANDLER,
41478         ZEND_MUL_SPEC_CV_CONST_HANDLER,
41479         ZEND_MUL_SPEC_CV_TMP_HANDLER,
41480         ZEND_MUL_SPEC_CV_VAR_HANDLER,
41481         ZEND_NULL_HANDLER,
41482         ZEND_MUL_SPEC_CV_CV_HANDLER,
41483         ZEND_DIV_SPEC_CONST_CONST_HANDLER,
41484         ZEND_DIV_SPEC_CONST_TMP_HANDLER,
41485         ZEND_DIV_SPEC_CONST_VAR_HANDLER,
41486         ZEND_NULL_HANDLER,
41487         ZEND_DIV_SPEC_CONST_CV_HANDLER,
41488         ZEND_DIV_SPEC_TMP_CONST_HANDLER,
41489         ZEND_DIV_SPEC_TMP_TMP_HANDLER,
41490         ZEND_DIV_SPEC_TMP_VAR_HANDLER,
41491         ZEND_NULL_HANDLER,
41492         ZEND_DIV_SPEC_TMP_CV_HANDLER,
41493         ZEND_DIV_SPEC_VAR_CONST_HANDLER,
41494         ZEND_DIV_SPEC_VAR_TMP_HANDLER,
41495         ZEND_DIV_SPEC_VAR_VAR_HANDLER,
41496         ZEND_NULL_HANDLER,
41497         ZEND_DIV_SPEC_VAR_CV_HANDLER,
41498         ZEND_NULL_HANDLER,
41499         ZEND_NULL_HANDLER,
41500         ZEND_NULL_HANDLER,
41501         ZEND_NULL_HANDLER,
41502         ZEND_NULL_HANDLER,
41503         ZEND_DIV_SPEC_CV_CONST_HANDLER,
41504         ZEND_DIV_SPEC_CV_TMP_HANDLER,
41505         ZEND_DIV_SPEC_CV_VAR_HANDLER,
41506         ZEND_NULL_HANDLER,
41507         ZEND_DIV_SPEC_CV_CV_HANDLER,
41508         ZEND_MOD_SPEC_CONST_CONST_HANDLER,
41509         ZEND_MOD_SPEC_CONST_TMP_HANDLER,
41510         ZEND_MOD_SPEC_CONST_VAR_HANDLER,
41511         ZEND_NULL_HANDLER,
41512         ZEND_MOD_SPEC_CONST_CV_HANDLER,
41513         ZEND_MOD_SPEC_TMP_CONST_HANDLER,
41514         ZEND_MOD_SPEC_TMP_TMP_HANDLER,
41515         ZEND_MOD_SPEC_TMP_VAR_HANDLER,
41516         ZEND_NULL_HANDLER,
41517         ZEND_MOD_SPEC_TMP_CV_HANDLER,
41518         ZEND_MOD_SPEC_VAR_CONST_HANDLER,
41519         ZEND_MOD_SPEC_VAR_TMP_HANDLER,
41520         ZEND_MOD_SPEC_VAR_VAR_HANDLER,
41521         ZEND_NULL_HANDLER,
41522         ZEND_MOD_SPEC_VAR_CV_HANDLER,
41523         ZEND_NULL_HANDLER,
41524         ZEND_NULL_HANDLER,
41525         ZEND_NULL_HANDLER,
41526         ZEND_NULL_HANDLER,
41527         ZEND_NULL_HANDLER,
41528         ZEND_MOD_SPEC_CV_CONST_HANDLER,
41529         ZEND_MOD_SPEC_CV_TMP_HANDLER,
41530         ZEND_MOD_SPEC_CV_VAR_HANDLER,
41531         ZEND_NULL_HANDLER,
41532         ZEND_MOD_SPEC_CV_CV_HANDLER,
41533         ZEND_SL_SPEC_CONST_CONST_HANDLER,
41534         ZEND_SL_SPEC_CONST_TMP_HANDLER,
41535         ZEND_SL_SPEC_CONST_VAR_HANDLER,
41536         ZEND_NULL_HANDLER,
41537         ZEND_SL_SPEC_CONST_CV_HANDLER,
41538         ZEND_SL_SPEC_TMP_CONST_HANDLER,
41539         ZEND_SL_SPEC_TMP_TMP_HANDLER,
41540         ZEND_SL_SPEC_TMP_VAR_HANDLER,
41541         ZEND_NULL_HANDLER,
41542         ZEND_SL_SPEC_TMP_CV_HANDLER,
41543         ZEND_SL_SPEC_VAR_CONST_HANDLER,
41544         ZEND_SL_SPEC_VAR_TMP_HANDLER,
41545         ZEND_SL_SPEC_VAR_VAR_HANDLER,
41546         ZEND_NULL_HANDLER,
41547         ZEND_SL_SPEC_VAR_CV_HANDLER,
41548         ZEND_NULL_HANDLER,
41549         ZEND_NULL_HANDLER,
41550         ZEND_NULL_HANDLER,
41551         ZEND_NULL_HANDLER,
41552         ZEND_NULL_HANDLER,
41553         ZEND_SL_SPEC_CV_CONST_HANDLER,
41554         ZEND_SL_SPEC_CV_TMP_HANDLER,
41555         ZEND_SL_SPEC_CV_VAR_HANDLER,
41556         ZEND_NULL_HANDLER,
41557         ZEND_SL_SPEC_CV_CV_HANDLER,
41558         ZEND_SR_SPEC_CONST_CONST_HANDLER,
41559         ZEND_SR_SPEC_CONST_TMP_HANDLER,
41560         ZEND_SR_SPEC_CONST_VAR_HANDLER,
41561         ZEND_NULL_HANDLER,
41562         ZEND_SR_SPEC_CONST_CV_HANDLER,
41563         ZEND_SR_SPEC_TMP_CONST_HANDLER,
41564         ZEND_SR_SPEC_TMP_TMP_HANDLER,
41565         ZEND_SR_SPEC_TMP_VAR_HANDLER,
41566         ZEND_NULL_HANDLER,
41567         ZEND_SR_SPEC_TMP_CV_HANDLER,
41568         ZEND_SR_SPEC_VAR_CONST_HANDLER,
41569         ZEND_SR_SPEC_VAR_TMP_HANDLER,
41570         ZEND_SR_SPEC_VAR_VAR_HANDLER,
41571         ZEND_NULL_HANDLER,
41572         ZEND_SR_SPEC_VAR_CV_HANDLER,
41573         ZEND_NULL_HANDLER,
41574         ZEND_NULL_HANDLER,
41575         ZEND_NULL_HANDLER,
41576         ZEND_NULL_HANDLER,
41577         ZEND_NULL_HANDLER,
41578         ZEND_SR_SPEC_CV_CONST_HANDLER,
41579         ZEND_SR_SPEC_CV_TMP_HANDLER,
41580         ZEND_SR_SPEC_CV_VAR_HANDLER,
41581         ZEND_NULL_HANDLER,
41582         ZEND_SR_SPEC_CV_CV_HANDLER,
41583         ZEND_CONCAT_SPEC_CONST_CONST_HANDLER,
41584         ZEND_CONCAT_SPEC_CONST_TMP_HANDLER,
41585         ZEND_CONCAT_SPEC_CONST_VAR_HANDLER,
41586         ZEND_NULL_HANDLER,
41587         ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
41588         ZEND_CONCAT_SPEC_TMP_CONST_HANDLER,
41589         ZEND_CONCAT_SPEC_TMP_TMP_HANDLER,
41590         ZEND_CONCAT_SPEC_TMP_VAR_HANDLER,
41591         ZEND_NULL_HANDLER,
41592         ZEND_CONCAT_SPEC_TMP_CV_HANDLER,
41593         ZEND_CONCAT_SPEC_VAR_CONST_HANDLER,
41594         ZEND_CONCAT_SPEC_VAR_TMP_HANDLER,
41595         ZEND_CONCAT_SPEC_VAR_VAR_HANDLER,
41596         ZEND_NULL_HANDLER,
41597         ZEND_CONCAT_SPEC_VAR_CV_HANDLER,
41598         ZEND_NULL_HANDLER,
41599         ZEND_NULL_HANDLER,
41600         ZEND_NULL_HANDLER,
41601         ZEND_NULL_HANDLER,
41602         ZEND_NULL_HANDLER,
41603         ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
41604         ZEND_CONCAT_SPEC_CV_TMP_HANDLER,
41605         ZEND_CONCAT_SPEC_CV_VAR_HANDLER,
41606         ZEND_NULL_HANDLER,
41607         ZEND_CONCAT_SPEC_CV_CV_HANDLER,
41608         ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
41609         ZEND_BW_OR_SPEC_CONST_TMP_HANDLER,
41610         ZEND_BW_OR_SPEC_CONST_VAR_HANDLER,
41611         ZEND_NULL_HANDLER,
41612         ZEND_BW_OR_SPEC_CONST_CV_HANDLER,
41613         ZEND_BW_OR_SPEC_TMP_CONST_HANDLER,
41614         ZEND_BW_OR_SPEC_TMP_TMP_HANDLER,
41615         ZEND_BW_OR_SPEC_TMP_VAR_HANDLER,
41616         ZEND_NULL_HANDLER,
41617         ZEND_BW_OR_SPEC_TMP_CV_HANDLER,
41618         ZEND_BW_OR_SPEC_VAR_CONST_HANDLER,
41619         ZEND_BW_OR_SPEC_VAR_TMP_HANDLER,
41620         ZEND_BW_OR_SPEC_VAR_VAR_HANDLER,
41621         ZEND_NULL_HANDLER,
41622         ZEND_BW_OR_SPEC_VAR_CV_HANDLER,
41623         ZEND_NULL_HANDLER,
41624         ZEND_NULL_HANDLER,
41625         ZEND_NULL_HANDLER,
41626         ZEND_NULL_HANDLER,
41627         ZEND_NULL_HANDLER,
41628         ZEND_BW_OR_SPEC_CV_CONST_HANDLER,
41629         ZEND_BW_OR_SPEC_CV_TMP_HANDLER,
41630         ZEND_BW_OR_SPEC_CV_VAR_HANDLER,
41631         ZEND_NULL_HANDLER,
41632         ZEND_BW_OR_SPEC_CV_CV_HANDLER,
41633         ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
41634         ZEND_BW_AND_SPEC_CONST_TMP_HANDLER,
41635         ZEND_BW_AND_SPEC_CONST_VAR_HANDLER,
41636         ZEND_NULL_HANDLER,
41637         ZEND_BW_AND_SPEC_CONST_CV_HANDLER,
41638         ZEND_BW_AND_SPEC_TMP_CONST_HANDLER,
41639         ZEND_BW_AND_SPEC_TMP_TMP_HANDLER,
41640         ZEND_BW_AND_SPEC_TMP_VAR_HANDLER,
41641         ZEND_NULL_HANDLER,
41642         ZEND_BW_AND_SPEC_TMP_CV_HANDLER,
41643         ZEND_BW_AND_SPEC_VAR_CONST_HANDLER,
41644         ZEND_BW_AND_SPEC_VAR_TMP_HANDLER,
41645         ZEND_BW_AND_SPEC_VAR_VAR_HANDLER,
41646         ZEND_NULL_HANDLER,
41647         ZEND_BW_AND_SPEC_VAR_CV_HANDLER,
41648         ZEND_NULL_HANDLER,
41649         ZEND_NULL_HANDLER,
41650         ZEND_NULL_HANDLER,
41651         ZEND_NULL_HANDLER,
41652         ZEND_NULL_HANDLER,
41653         ZEND_BW_AND_SPEC_CV_CONST_HANDLER,
41654         ZEND_BW_AND_SPEC_CV_TMP_HANDLER,
41655         ZEND_BW_AND_SPEC_CV_VAR_HANDLER,
41656         ZEND_NULL_HANDLER,
41657         ZEND_BW_AND_SPEC_CV_CV_HANDLER,
41658         ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
41659         ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER,
41660         ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER,
41661         ZEND_NULL_HANDLER,
41662         ZEND_BW_XOR_SPEC_CONST_CV_HANDLER,
41663         ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER,
41664         ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER,
41665         ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER,
41666         ZEND_NULL_HANDLER,
41667         ZEND_BW_XOR_SPEC_TMP_CV_HANDLER,
41668         ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER,
41669         ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER,
41670         ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER,
41671         ZEND_NULL_HANDLER,
41672         ZEND_BW_XOR_SPEC_VAR_CV_HANDLER,
41673         ZEND_NULL_HANDLER,
41674         ZEND_NULL_HANDLER,
41675         ZEND_NULL_HANDLER,
41676         ZEND_NULL_HANDLER,
41677         ZEND_NULL_HANDLER,
41678         ZEND_BW_XOR_SPEC_CV_CONST_HANDLER,
41679         ZEND_BW_XOR_SPEC_CV_TMP_HANDLER,
41680         ZEND_BW_XOR_SPEC_CV_VAR_HANDLER,
41681         ZEND_NULL_HANDLER,
41682         ZEND_BW_XOR_SPEC_CV_CV_HANDLER,
41683         ZEND_BW_NOT_SPEC_CONST_HANDLER,
41684         ZEND_BW_NOT_SPEC_CONST_HANDLER,
41685         ZEND_BW_NOT_SPEC_CONST_HANDLER,
41686         ZEND_BW_NOT_SPEC_CONST_HANDLER,
41687         ZEND_BW_NOT_SPEC_CONST_HANDLER,
41688         ZEND_BW_NOT_SPEC_TMP_HANDLER,
41689         ZEND_BW_NOT_SPEC_TMP_HANDLER,
41690         ZEND_BW_NOT_SPEC_TMP_HANDLER,
41691         ZEND_BW_NOT_SPEC_TMP_HANDLER,
41692         ZEND_BW_NOT_SPEC_TMP_HANDLER,
41693         ZEND_BW_NOT_SPEC_VAR_HANDLER,
41694         ZEND_BW_NOT_SPEC_VAR_HANDLER,
41695         ZEND_BW_NOT_SPEC_VAR_HANDLER,
41696         ZEND_BW_NOT_SPEC_VAR_HANDLER,
41697         ZEND_BW_NOT_SPEC_VAR_HANDLER,
41698         ZEND_NULL_HANDLER,
41699         ZEND_NULL_HANDLER,
41700         ZEND_NULL_HANDLER,
41701         ZEND_NULL_HANDLER,
41702         ZEND_NULL_HANDLER,
41703         ZEND_BW_NOT_SPEC_CV_HANDLER,
41704         ZEND_BW_NOT_SPEC_CV_HANDLER,
41705         ZEND_BW_NOT_SPEC_CV_HANDLER,
41706         ZEND_BW_NOT_SPEC_CV_HANDLER,
41707         ZEND_BW_NOT_SPEC_CV_HANDLER,
41708         ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
41709         ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
41710         ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
41711         ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
41712         ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
41713         ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
41714         ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
41715         ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
41716         ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
41717         ZEND_BOOL_NOT_SPEC_TMP_HANDLER,
41718         ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
41719         ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
41720         ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
41721         ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
41722         ZEND_BOOL_NOT_SPEC_VAR_HANDLER,
41723         ZEND_NULL_HANDLER,
41724         ZEND_NULL_HANDLER,
41725         ZEND_NULL_HANDLER,
41726         ZEND_NULL_HANDLER,
41727         ZEND_NULL_HANDLER,
41728         ZEND_BOOL_NOT_SPEC_CV_HANDLER,
41729         ZEND_BOOL_NOT_SPEC_CV_HANDLER,
41730         ZEND_BOOL_NOT_SPEC_CV_HANDLER,
41731         ZEND_BOOL_NOT_SPEC_CV_HANDLER,
41732         ZEND_BOOL_NOT_SPEC_CV_HANDLER,
41733         ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
41734         ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER,
41735         ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER,
41736         ZEND_NULL_HANDLER,
41737         ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER,
41738         ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER,
41739         ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER,
41740         ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER,
41741         ZEND_NULL_HANDLER,
41742         ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER,
41743         ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER,
41744         ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER,
41745         ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER,
41746         ZEND_NULL_HANDLER,
41747         ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER,
41748         ZEND_NULL_HANDLER,
41749         ZEND_NULL_HANDLER,
41750         ZEND_NULL_HANDLER,
41751         ZEND_NULL_HANDLER,
41752         ZEND_NULL_HANDLER,
41753         ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
41754         ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER,
41755         ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER,
41756         ZEND_NULL_HANDLER,
41757         ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
41758         ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
41759         ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER,
41760         ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER,
41761         ZEND_NULL_HANDLER,
41762         ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER,
41763         ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
41764         ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
41765         ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER,
41766         ZEND_NULL_HANDLER,
41767         ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER,
41768         ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
41769         ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
41770         ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
41771         ZEND_NULL_HANDLER,
41772         ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER,
41773         ZEND_NULL_HANDLER,
41774         ZEND_NULL_HANDLER,
41775         ZEND_NULL_HANDLER,
41776         ZEND_NULL_HANDLER,
41777         ZEND_NULL_HANDLER,
41778         ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
41779         ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
41780         ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
41781         ZEND_NULL_HANDLER,
41782         ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
41783         ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
41784         ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER,
41785         ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER,
41786         ZEND_NULL_HANDLER,
41787         ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER,
41788         ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
41789         ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
41790         ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER,
41791         ZEND_NULL_HANDLER,
41792         ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER,
41793         ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
41794         ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
41795         ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
41796         ZEND_NULL_HANDLER,
41797         ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER,
41798         ZEND_NULL_HANDLER,
41799         ZEND_NULL_HANDLER,
41800         ZEND_NULL_HANDLER,
41801         ZEND_NULL_HANDLER,
41802         ZEND_NULL_HANDLER,
41803         ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
41804         ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
41805         ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
41806         ZEND_NULL_HANDLER,
41807         ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
41808         ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
41809         ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER,
41810         ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER,
41811         ZEND_NULL_HANDLER,
41812         ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER,
41813         ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER,
41814         ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER,
41815         ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER,
41816         ZEND_NULL_HANDLER,
41817         ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER,
41818         ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER,
41819         ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER,
41820         ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER,
41821         ZEND_NULL_HANDLER,
41822         ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER,
41823         ZEND_NULL_HANDLER,
41824         ZEND_NULL_HANDLER,
41825         ZEND_NULL_HANDLER,
41826         ZEND_NULL_HANDLER,
41827         ZEND_NULL_HANDLER,
41828         ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
41829         ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER,
41830         ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER,
41831         ZEND_NULL_HANDLER,
41832         ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
41833         ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
41834         ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER,
41835         ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER,
41836         ZEND_NULL_HANDLER,
41837         ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER,
41838         ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER,
41839         ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER,
41840         ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER,
41841         ZEND_NULL_HANDLER,
41842         ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER,
41843         ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER,
41844         ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER,
41845         ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER,
41846         ZEND_NULL_HANDLER,
41847         ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER,
41848         ZEND_NULL_HANDLER,
41849         ZEND_NULL_HANDLER,
41850         ZEND_NULL_HANDLER,
41851         ZEND_NULL_HANDLER,
41852         ZEND_NULL_HANDLER,
41853         ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
41854         ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER,
41855         ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER,
41856         ZEND_NULL_HANDLER,
41857         ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
41858         ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
41859         ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER,
41860         ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER,
41861         ZEND_NULL_HANDLER,
41862         ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER,
41863         ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER,
41864         ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER,
41865         ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER,
41866         ZEND_NULL_HANDLER,
41867         ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER,
41868         ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER,
41869         ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER,
41870         ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER,
41871         ZEND_NULL_HANDLER,
41872         ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER,
41873         ZEND_NULL_HANDLER,
41874         ZEND_NULL_HANDLER,
41875         ZEND_NULL_HANDLER,
41876         ZEND_NULL_HANDLER,
41877         ZEND_NULL_HANDLER,
41878         ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER,
41879         ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER,
41880         ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER,
41881         ZEND_NULL_HANDLER,
41882         ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER,
41883         ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
41884         ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER,
41885         ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER,
41886         ZEND_NULL_HANDLER,
41887         ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER,
41888         ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER,
41889         ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER,
41890         ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER,
41891         ZEND_NULL_HANDLER,
41892         ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER,
41893         ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER,
41894         ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER,
41895         ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER,
41896         ZEND_NULL_HANDLER,
41897         ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER,
41898         ZEND_NULL_HANDLER,
41899         ZEND_NULL_HANDLER,
41900         ZEND_NULL_HANDLER,
41901         ZEND_NULL_HANDLER,
41902         ZEND_NULL_HANDLER,
41903         ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER,
41904         ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER,
41905         ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER,
41906         ZEND_NULL_HANDLER,
41907         ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER,
41908         ZEND_CAST_SPEC_CONST_HANDLER,
41909         ZEND_CAST_SPEC_CONST_HANDLER,
41910         ZEND_CAST_SPEC_CONST_HANDLER,
41911         ZEND_CAST_SPEC_CONST_HANDLER,
41912         ZEND_CAST_SPEC_CONST_HANDLER,
41913         ZEND_CAST_SPEC_TMP_HANDLER,
41914         ZEND_CAST_SPEC_TMP_HANDLER,
41915         ZEND_CAST_SPEC_TMP_HANDLER,
41916         ZEND_CAST_SPEC_TMP_HANDLER,
41917         ZEND_CAST_SPEC_TMP_HANDLER,
41918         ZEND_CAST_SPEC_VAR_HANDLER,
41919         ZEND_CAST_SPEC_VAR_HANDLER,
41920         ZEND_CAST_SPEC_VAR_HANDLER,
41921         ZEND_CAST_SPEC_VAR_HANDLER,
41922         ZEND_CAST_SPEC_VAR_HANDLER,
41923         ZEND_NULL_HANDLER,
41924         ZEND_NULL_HANDLER,
41925         ZEND_NULL_HANDLER,
41926         ZEND_NULL_HANDLER,
41927         ZEND_NULL_HANDLER,
41928         ZEND_CAST_SPEC_CV_HANDLER,
41929         ZEND_CAST_SPEC_CV_HANDLER,
41930         ZEND_CAST_SPEC_CV_HANDLER,
41931         ZEND_CAST_SPEC_CV_HANDLER,
41932         ZEND_CAST_SPEC_CV_HANDLER,
41933         ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
41934         ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
41935         ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
41936         ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
41937         ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
41938         ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
41939         ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
41940         ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
41941         ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
41942         ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
41943         ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
41944         ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
41945         ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
41946         ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
41947         ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
41948         ZEND_NULL_HANDLER,
41949         ZEND_NULL_HANDLER,
41950         ZEND_NULL_HANDLER,
41951         ZEND_NULL_HANDLER,
41952         ZEND_NULL_HANDLER,
41953         ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
41954         ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
41955         ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
41956         ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
41957         ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
41958         ZEND_NULL_HANDLER,
41959         ZEND_NULL_HANDLER,
41960         ZEND_NULL_HANDLER,
41961         ZEND_NULL_HANDLER,
41962         ZEND_NULL_HANDLER,
41963         ZEND_NULL_HANDLER,
41964         ZEND_NULL_HANDLER,
41965         ZEND_NULL_HANDLER,
41966         ZEND_NULL_HANDLER,
41967         ZEND_NULL_HANDLER,
41968         ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER,
41969         ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER,
41970         ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER,
41971         ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER,
41972         ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER,
41973         ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER,
41974         ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER,
41975         ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER,
41976         ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER,
41977         ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER,
41978         ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER,
41979         ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER,
41980         ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER,
41981         ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER,
41982         ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER,
41983         ZEND_NULL_HANDLER,
41984         ZEND_NULL_HANDLER,
41985         ZEND_NULL_HANDLER,
41986         ZEND_NULL_HANDLER,
41987         ZEND_NULL_HANDLER,
41988         ZEND_NULL_HANDLER,
41989         ZEND_NULL_HANDLER,
41990         ZEND_NULL_HANDLER,
41991         ZEND_NULL_HANDLER,
41992         ZEND_NULL_HANDLER,
41993         ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER,
41994         ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER,
41995         ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER,
41996         ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER,
41997         ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER,
41998         ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER,
41999         ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER,
42000         ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER,
42001         ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER,
42002         ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER,
42003         ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER,
42004         ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER,
42005         ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER,
42006         ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER,
42007         ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER,
42008         ZEND_NULL_HANDLER,
42009         ZEND_NULL_HANDLER,
42010         ZEND_NULL_HANDLER,
42011         ZEND_NULL_HANDLER,
42012         ZEND_NULL_HANDLER,
42013         ZEND_NULL_HANDLER,
42014         ZEND_NULL_HANDLER,
42015         ZEND_NULL_HANDLER,
42016         ZEND_NULL_HANDLER,
42017         ZEND_NULL_HANDLER,
42018         ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER,
42019         ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER,
42020         ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER,
42021         ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER,
42022         ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER,
42023         ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER,
42024         ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER,
42025         ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER,
42026         ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER,
42027         ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER,
42028         ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER,
42029         ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER,
42030         ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER,
42031         ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER,
42032         ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER,
42033         ZEND_NULL_HANDLER,
42034         ZEND_NULL_HANDLER,
42035         ZEND_NULL_HANDLER,
42036         ZEND_NULL_HANDLER,
42037         ZEND_NULL_HANDLER,
42038         ZEND_NULL_HANDLER,
42039         ZEND_NULL_HANDLER,
42040         ZEND_NULL_HANDLER,
42041         ZEND_NULL_HANDLER,
42042         ZEND_NULL_HANDLER,
42043         ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER,
42044         ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER,
42045         ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER,
42046         ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER,
42047         ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER,
42048         ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER,
42049         ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER,
42050         ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER,
42051         ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER,
42052         ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER,
42053         ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER,
42054         ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER,
42055         ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER,
42056         ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER,
42057         ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER,
42058         ZEND_NULL_HANDLER,
42059         ZEND_NULL_HANDLER,
42060         ZEND_NULL_HANDLER,
42061         ZEND_NULL_HANDLER,
42062         ZEND_NULL_HANDLER,
42063         ZEND_NULL_HANDLER,
42064         ZEND_NULL_HANDLER,
42065         ZEND_NULL_HANDLER,
42066         ZEND_NULL_HANDLER,
42067         ZEND_NULL_HANDLER,
42068         ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER,
42069         ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER,
42070         ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER,
42071         ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER,
42072         ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER,
42073         ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER,
42074         ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER,
42075         ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER,
42076         ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER,
42077         ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER,
42078         ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER,
42079         ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER,
42080         ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER,
42081         ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER,
42082         ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER,
42083         ZEND_NULL_HANDLER,
42084         ZEND_NULL_HANDLER,
42085         ZEND_NULL_HANDLER,
42086         ZEND_NULL_HANDLER,
42087         ZEND_NULL_HANDLER,
42088         ZEND_NULL_HANDLER,
42089         ZEND_NULL_HANDLER,
42090         ZEND_NULL_HANDLER,
42091         ZEND_NULL_HANDLER,
42092         ZEND_NULL_HANDLER,
42093         ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER,
42094         ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER,
42095         ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER,
42096         ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER,
42097         ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER,
42098         ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER,
42099         ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER,
42100         ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER,
42101         ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER,
42102         ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER,
42103         ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER,
42104         ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER,
42105         ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER,
42106         ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER,
42107         ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER,
42108         ZEND_NULL_HANDLER,
42109         ZEND_NULL_HANDLER,
42110         ZEND_NULL_HANDLER,
42111         ZEND_NULL_HANDLER,
42112         ZEND_NULL_HANDLER,
42113         ZEND_NULL_HANDLER,
42114         ZEND_NULL_HANDLER,
42115         ZEND_NULL_HANDLER,
42116         ZEND_NULL_HANDLER,
42117         ZEND_NULL_HANDLER,
42118         ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER,
42119         ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER,
42120         ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER,
42121         ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER,
42122         ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER,
42123         ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER,
42124         ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER,
42125         ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER,
42126         ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER,
42127         ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER,
42128         ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER,
42129         ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER,
42130         ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER,
42131         ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER,
42132         ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER,
42133         ZEND_NULL_HANDLER,
42134         ZEND_NULL_HANDLER,
42135         ZEND_NULL_HANDLER,
42136         ZEND_NULL_HANDLER,
42137         ZEND_NULL_HANDLER,
42138         ZEND_NULL_HANDLER,
42139         ZEND_NULL_HANDLER,
42140         ZEND_NULL_HANDLER,
42141         ZEND_NULL_HANDLER,
42142         ZEND_NULL_HANDLER,
42143         ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER,
42144         ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER,
42145         ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER,
42146         ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER,
42147         ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER,
42148         ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER,
42149         ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER,
42150         ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER,
42151         ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER,
42152         ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER,
42153         ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER,
42154         ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER,
42155         ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER,
42156         ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER,
42157         ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER,
42158         ZEND_NULL_HANDLER,
42159         ZEND_NULL_HANDLER,
42160         ZEND_NULL_HANDLER,
42161         ZEND_NULL_HANDLER,
42162         ZEND_NULL_HANDLER,
42163         ZEND_NULL_HANDLER,
42164         ZEND_NULL_HANDLER,
42165         ZEND_NULL_HANDLER,
42166         ZEND_NULL_HANDLER,
42167         ZEND_NULL_HANDLER,
42168         ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER,
42169         ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER,
42170         ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER,
42171         ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER,
42172         ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER,
42173         ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER,
42174         ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER,
42175         ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER,
42176         ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER,
42177         ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER,
42178         ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER,
42179         ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER,
42180         ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER,
42181         ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER,
42182         ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER,
42183         ZEND_NULL_HANDLER,
42184         ZEND_NULL_HANDLER,
42185         ZEND_NULL_HANDLER,
42186         ZEND_NULL_HANDLER,
42187         ZEND_NULL_HANDLER,
42188         ZEND_NULL_HANDLER,
42189         ZEND_NULL_HANDLER,
42190         ZEND_NULL_HANDLER,
42191         ZEND_NULL_HANDLER,
42192         ZEND_NULL_HANDLER,
42193         ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER,
42194         ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER,
42195         ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER,
42196         ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER,
42197         ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER,
42198         ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER,
42199         ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER,
42200         ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER,
42201         ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER,
42202         ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER,
42203         ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER,
42204         ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER,
42205         ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER,
42206         ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER,
42207         ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER,
42208         ZEND_NULL_HANDLER,
42209         ZEND_NULL_HANDLER,
42210         ZEND_NULL_HANDLER,
42211         ZEND_NULL_HANDLER,
42212         ZEND_NULL_HANDLER,
42213         ZEND_NULL_HANDLER,
42214         ZEND_NULL_HANDLER,
42215         ZEND_NULL_HANDLER,
42216         ZEND_NULL_HANDLER,
42217         ZEND_NULL_HANDLER,
42218         ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER,
42219         ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER,
42220         ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER,
42221         ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER,
42222         ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER,
42223         ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER,
42224         ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER,
42225         ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER,
42226         ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER,
42227         ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER,
42228         ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER,
42229         ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER,
42230         ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER,
42231         ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER,
42232         ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER,
42233         ZEND_NULL_HANDLER,
42234         ZEND_NULL_HANDLER,
42235         ZEND_NULL_HANDLER,
42236         ZEND_NULL_HANDLER,
42237         ZEND_NULL_HANDLER,
42238         ZEND_NULL_HANDLER,
42239         ZEND_NULL_HANDLER,
42240         ZEND_NULL_HANDLER,
42241         ZEND_NULL_HANDLER,
42242         ZEND_NULL_HANDLER,
42243         ZEND_PRE_INC_SPEC_VAR_HANDLER,
42244         ZEND_PRE_INC_SPEC_VAR_HANDLER,
42245         ZEND_PRE_INC_SPEC_VAR_HANDLER,
42246         ZEND_PRE_INC_SPEC_VAR_HANDLER,
42247         ZEND_PRE_INC_SPEC_VAR_HANDLER,
42248         ZEND_NULL_HANDLER,
42249         ZEND_NULL_HANDLER,
42250         ZEND_NULL_HANDLER,
42251         ZEND_NULL_HANDLER,
42252         ZEND_NULL_HANDLER,
42253         ZEND_PRE_INC_SPEC_CV_HANDLER,
42254         ZEND_PRE_INC_SPEC_CV_HANDLER,
42255         ZEND_PRE_INC_SPEC_CV_HANDLER,
42256         ZEND_PRE_INC_SPEC_CV_HANDLER,
42257         ZEND_PRE_INC_SPEC_CV_HANDLER,
42258         ZEND_NULL_HANDLER,
42259         ZEND_NULL_HANDLER,
42260         ZEND_NULL_HANDLER,
42261         ZEND_NULL_HANDLER,
42262         ZEND_NULL_HANDLER,
42263         ZEND_NULL_HANDLER,
42264         ZEND_NULL_HANDLER,
42265         ZEND_NULL_HANDLER,
42266         ZEND_NULL_HANDLER,
42267         ZEND_NULL_HANDLER,
42268         ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42269         ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42270         ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42271         ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42272         ZEND_PRE_DEC_SPEC_VAR_HANDLER,
42273         ZEND_NULL_HANDLER,
42274         ZEND_NULL_HANDLER,
42275         ZEND_NULL_HANDLER,
42276         ZEND_NULL_HANDLER,
42277         ZEND_NULL_HANDLER,
42278         ZEND_PRE_DEC_SPEC_CV_HANDLER,
42279         ZEND_PRE_DEC_SPEC_CV_HANDLER,
42280         ZEND_PRE_DEC_SPEC_CV_HANDLER,
42281         ZEND_PRE_DEC_SPEC_CV_HANDLER,
42282         ZEND_PRE_DEC_SPEC_CV_HANDLER,
42283         ZEND_NULL_HANDLER,
42284         ZEND_NULL_HANDLER,
42285         ZEND_NULL_HANDLER,
42286         ZEND_NULL_HANDLER,
42287         ZEND_NULL_HANDLER,
42288         ZEND_NULL_HANDLER,
42289         ZEND_NULL_HANDLER,
42290         ZEND_NULL_HANDLER,
42291         ZEND_NULL_HANDLER,
42292         ZEND_NULL_HANDLER,
42293         ZEND_POST_INC_SPEC_VAR_HANDLER,
42294         ZEND_POST_INC_SPEC_VAR_HANDLER,
42295         ZEND_POST_INC_SPEC_VAR_HANDLER,
42296         ZEND_POST_INC_SPEC_VAR_HANDLER,
42297         ZEND_POST_INC_SPEC_VAR_HANDLER,
42298         ZEND_NULL_HANDLER,
42299         ZEND_NULL_HANDLER,
42300         ZEND_NULL_HANDLER,
42301         ZEND_NULL_HANDLER,
42302         ZEND_NULL_HANDLER,
42303         ZEND_POST_INC_SPEC_CV_HANDLER,
42304         ZEND_POST_INC_SPEC_CV_HANDLER,
42305         ZEND_POST_INC_SPEC_CV_HANDLER,
42306         ZEND_POST_INC_SPEC_CV_HANDLER,
42307         ZEND_POST_INC_SPEC_CV_HANDLER,
42308         ZEND_NULL_HANDLER,
42309         ZEND_NULL_HANDLER,
42310         ZEND_NULL_HANDLER,
42311         ZEND_NULL_HANDLER,
42312         ZEND_NULL_HANDLER,
42313         ZEND_NULL_HANDLER,
42314         ZEND_NULL_HANDLER,
42315         ZEND_NULL_HANDLER,
42316         ZEND_NULL_HANDLER,
42317         ZEND_NULL_HANDLER,
42318         ZEND_POST_DEC_SPEC_VAR_HANDLER,
42319         ZEND_POST_DEC_SPEC_VAR_HANDLER,
42320         ZEND_POST_DEC_SPEC_VAR_HANDLER,
42321         ZEND_POST_DEC_SPEC_VAR_HANDLER,
42322         ZEND_POST_DEC_SPEC_VAR_HANDLER,
42323         ZEND_NULL_HANDLER,
42324         ZEND_NULL_HANDLER,
42325         ZEND_NULL_HANDLER,
42326         ZEND_NULL_HANDLER,
42327         ZEND_NULL_HANDLER,
42328         ZEND_POST_DEC_SPEC_CV_HANDLER,
42329         ZEND_POST_DEC_SPEC_CV_HANDLER,
42330         ZEND_POST_DEC_SPEC_CV_HANDLER,
42331         ZEND_POST_DEC_SPEC_CV_HANDLER,
42332         ZEND_POST_DEC_SPEC_CV_HANDLER,
42333         ZEND_NULL_HANDLER,
42334         ZEND_NULL_HANDLER,
42335         ZEND_NULL_HANDLER,
42336         ZEND_NULL_HANDLER,
42337         ZEND_NULL_HANDLER,
42338         ZEND_NULL_HANDLER,
42339         ZEND_NULL_HANDLER,
42340         ZEND_NULL_HANDLER,
42341         ZEND_NULL_HANDLER,
42342         ZEND_NULL_HANDLER,
42343         ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER,
42344         ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER,
42345         ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER,
42346         ZEND_NULL_HANDLER,
42347         ZEND_ASSIGN_SPEC_VAR_CV_HANDLER,
42348         ZEND_NULL_HANDLER,
42349         ZEND_NULL_HANDLER,
42350         ZEND_NULL_HANDLER,
42351         ZEND_NULL_HANDLER,
42352         ZEND_NULL_HANDLER,
42353         ZEND_ASSIGN_SPEC_CV_CONST_HANDLER,
42354         ZEND_ASSIGN_SPEC_CV_TMP_HANDLER,
42355         ZEND_ASSIGN_SPEC_CV_VAR_HANDLER,
42356         ZEND_NULL_HANDLER,
42357         ZEND_ASSIGN_SPEC_CV_CV_HANDLER,
42358         ZEND_NULL_HANDLER,
42359         ZEND_NULL_HANDLER,
42360         ZEND_NULL_HANDLER,
42361         ZEND_NULL_HANDLER,
42362         ZEND_NULL_HANDLER,
42363         ZEND_NULL_HANDLER,
42364         ZEND_NULL_HANDLER,
42365         ZEND_NULL_HANDLER,
42366         ZEND_NULL_HANDLER,
42367         ZEND_NULL_HANDLER,
42368         ZEND_NULL_HANDLER,
42369         ZEND_NULL_HANDLER,
42370         ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
42371         ZEND_NULL_HANDLER,
42372         ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
42373         ZEND_NULL_HANDLER,
42374         ZEND_NULL_HANDLER,
42375         ZEND_NULL_HANDLER,
42376         ZEND_NULL_HANDLER,
42377         ZEND_NULL_HANDLER,
42378         ZEND_NULL_HANDLER,
42379         ZEND_NULL_HANDLER,
42380         ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
42381         ZEND_NULL_HANDLER,
42382         ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
42383         ZEND_ECHO_SPEC_CONST_HANDLER,
42384         ZEND_ECHO_SPEC_CONST_HANDLER,
42385         ZEND_ECHO_SPEC_CONST_HANDLER,
42386         ZEND_ECHO_SPEC_CONST_HANDLER,
42387         ZEND_ECHO_SPEC_CONST_HANDLER,
42388         ZEND_ECHO_SPEC_TMP_HANDLER,
42389         ZEND_ECHO_SPEC_TMP_HANDLER,
42390         ZEND_ECHO_SPEC_TMP_HANDLER,
42391         ZEND_ECHO_SPEC_TMP_HANDLER,
42392         ZEND_ECHO_SPEC_TMP_HANDLER,
42393         ZEND_ECHO_SPEC_VAR_HANDLER,
42394         ZEND_ECHO_SPEC_VAR_HANDLER,
42395         ZEND_ECHO_SPEC_VAR_HANDLER,
42396         ZEND_ECHO_SPEC_VAR_HANDLER,
42397         ZEND_ECHO_SPEC_VAR_HANDLER,
42398         ZEND_NULL_HANDLER,
42399         ZEND_NULL_HANDLER,
42400         ZEND_NULL_HANDLER,
42401         ZEND_NULL_HANDLER,
42402         ZEND_NULL_HANDLER,
42403         ZEND_ECHO_SPEC_CV_HANDLER,
42404         ZEND_ECHO_SPEC_CV_HANDLER,
42405         ZEND_ECHO_SPEC_CV_HANDLER,
42406         ZEND_ECHO_SPEC_CV_HANDLER,
42407         ZEND_ECHO_SPEC_CV_HANDLER,
42408         ZEND_PRINT_SPEC_CONST_HANDLER,
42409         ZEND_PRINT_SPEC_CONST_HANDLER,
42410         ZEND_PRINT_SPEC_CONST_HANDLER,
42411         ZEND_PRINT_SPEC_CONST_HANDLER,
42412         ZEND_PRINT_SPEC_CONST_HANDLER,
42413         ZEND_PRINT_SPEC_TMP_HANDLER,
42414         ZEND_PRINT_SPEC_TMP_HANDLER,
42415         ZEND_PRINT_SPEC_TMP_HANDLER,
42416         ZEND_PRINT_SPEC_TMP_HANDLER,
42417         ZEND_PRINT_SPEC_TMP_HANDLER,
42418         ZEND_PRINT_SPEC_VAR_HANDLER,
42419         ZEND_PRINT_SPEC_VAR_HANDLER,
42420         ZEND_PRINT_SPEC_VAR_HANDLER,
42421         ZEND_PRINT_SPEC_VAR_HANDLER,
42422         ZEND_PRINT_SPEC_VAR_HANDLER,
42423         ZEND_NULL_HANDLER,
42424         ZEND_NULL_HANDLER,
42425         ZEND_NULL_HANDLER,
42426         ZEND_NULL_HANDLER,
42427         ZEND_NULL_HANDLER,
42428         ZEND_PRINT_SPEC_CV_HANDLER,
42429         ZEND_PRINT_SPEC_CV_HANDLER,
42430         ZEND_PRINT_SPEC_CV_HANDLER,
42431         ZEND_PRINT_SPEC_CV_HANDLER,
42432         ZEND_PRINT_SPEC_CV_HANDLER,
42433         ZEND_JMP_SPEC_HANDLER,
42434         ZEND_JMP_SPEC_HANDLER,
42435         ZEND_JMP_SPEC_HANDLER,
42436         ZEND_JMP_SPEC_HANDLER,
42437         ZEND_JMP_SPEC_HANDLER,
42438         ZEND_JMP_SPEC_HANDLER,
42439         ZEND_JMP_SPEC_HANDLER,
42440         ZEND_JMP_SPEC_HANDLER,
42441         ZEND_JMP_SPEC_HANDLER,
42442         ZEND_JMP_SPEC_HANDLER,
42443         ZEND_JMP_SPEC_HANDLER,
42444         ZEND_JMP_SPEC_HANDLER,
42445         ZEND_JMP_SPEC_HANDLER,
42446         ZEND_JMP_SPEC_HANDLER,
42447         ZEND_JMP_SPEC_HANDLER,
42448         ZEND_JMP_SPEC_HANDLER,
42449         ZEND_JMP_SPEC_HANDLER,
42450         ZEND_JMP_SPEC_HANDLER,
42451         ZEND_JMP_SPEC_HANDLER,
42452         ZEND_JMP_SPEC_HANDLER,
42453         ZEND_JMP_SPEC_HANDLER,
42454         ZEND_JMP_SPEC_HANDLER,
42455         ZEND_JMP_SPEC_HANDLER,
42456         ZEND_JMP_SPEC_HANDLER,
42457         ZEND_JMP_SPEC_HANDLER,
42458         ZEND_JMPZ_SPEC_CONST_HANDLER,
42459         ZEND_JMPZ_SPEC_CONST_HANDLER,
42460         ZEND_JMPZ_SPEC_CONST_HANDLER,
42461         ZEND_JMPZ_SPEC_CONST_HANDLER,
42462         ZEND_JMPZ_SPEC_CONST_HANDLER,
42463         ZEND_JMPZ_SPEC_TMP_HANDLER,
42464         ZEND_JMPZ_SPEC_TMP_HANDLER,
42465         ZEND_JMPZ_SPEC_TMP_HANDLER,
42466         ZEND_JMPZ_SPEC_TMP_HANDLER,
42467         ZEND_JMPZ_SPEC_TMP_HANDLER,
42468         ZEND_JMPZ_SPEC_VAR_HANDLER,
42469         ZEND_JMPZ_SPEC_VAR_HANDLER,
42470         ZEND_JMPZ_SPEC_VAR_HANDLER,
42471         ZEND_JMPZ_SPEC_VAR_HANDLER,
42472         ZEND_JMPZ_SPEC_VAR_HANDLER,
42473         ZEND_NULL_HANDLER,
42474         ZEND_NULL_HANDLER,
42475         ZEND_NULL_HANDLER,
42476         ZEND_NULL_HANDLER,
42477         ZEND_NULL_HANDLER,
42478         ZEND_JMPZ_SPEC_CV_HANDLER,
42479         ZEND_JMPZ_SPEC_CV_HANDLER,
42480         ZEND_JMPZ_SPEC_CV_HANDLER,
42481         ZEND_JMPZ_SPEC_CV_HANDLER,
42482         ZEND_JMPZ_SPEC_CV_HANDLER,
42483         ZEND_JMPNZ_SPEC_CONST_HANDLER,
42484         ZEND_JMPNZ_SPEC_CONST_HANDLER,
42485         ZEND_JMPNZ_SPEC_CONST_HANDLER,
42486         ZEND_JMPNZ_SPEC_CONST_HANDLER,
42487         ZEND_JMPNZ_SPEC_CONST_HANDLER,
42488         ZEND_JMPNZ_SPEC_TMP_HANDLER,
42489         ZEND_JMPNZ_SPEC_TMP_HANDLER,
42490         ZEND_JMPNZ_SPEC_TMP_HANDLER,
42491         ZEND_JMPNZ_SPEC_TMP_HANDLER,
42492         ZEND_JMPNZ_SPEC_TMP_HANDLER,
42493         ZEND_JMPNZ_SPEC_VAR_HANDLER,
42494         ZEND_JMPNZ_SPEC_VAR_HANDLER,
42495         ZEND_JMPNZ_SPEC_VAR_HANDLER,
42496         ZEND_JMPNZ_SPEC_VAR_HANDLER,
42497         ZEND_JMPNZ_SPEC_VAR_HANDLER,
42498         ZEND_NULL_HANDLER,
42499         ZEND_NULL_HANDLER,
42500         ZEND_NULL_HANDLER,
42501         ZEND_NULL_HANDLER,
42502         ZEND_NULL_HANDLER,
42503         ZEND_JMPNZ_SPEC_CV_HANDLER,
42504         ZEND_JMPNZ_SPEC_CV_HANDLER,
42505         ZEND_JMPNZ_SPEC_CV_HANDLER,
42506         ZEND_JMPNZ_SPEC_CV_HANDLER,
42507         ZEND_JMPNZ_SPEC_CV_HANDLER,
42508         ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42509         ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42510         ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42511         ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42512         ZEND_JMPZNZ_SPEC_CONST_HANDLER,
42513         ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42514         ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42515         ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42516         ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42517         ZEND_JMPZNZ_SPEC_TMP_HANDLER,
42518         ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42519         ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42520         ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42521         ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42522         ZEND_JMPZNZ_SPEC_VAR_HANDLER,
42523         ZEND_NULL_HANDLER,
42524         ZEND_NULL_HANDLER,
42525         ZEND_NULL_HANDLER,
42526         ZEND_NULL_HANDLER,
42527         ZEND_NULL_HANDLER,
42528         ZEND_JMPZNZ_SPEC_CV_HANDLER,
42529         ZEND_JMPZNZ_SPEC_CV_HANDLER,
42530         ZEND_JMPZNZ_SPEC_CV_HANDLER,
42531         ZEND_JMPZNZ_SPEC_CV_HANDLER,
42532         ZEND_JMPZNZ_SPEC_CV_HANDLER,
42533         ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42534         ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42535         ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42536         ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42537         ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
42538         ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42539         ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42540         ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42541         ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42542         ZEND_JMPZ_EX_SPEC_TMP_HANDLER,
42543         ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42544         ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42545         ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42546         ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42547         ZEND_JMPZ_EX_SPEC_VAR_HANDLER,
42548         ZEND_NULL_HANDLER,
42549         ZEND_NULL_HANDLER,
42550         ZEND_NULL_HANDLER,
42551         ZEND_NULL_HANDLER,
42552         ZEND_NULL_HANDLER,
42553         ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42554         ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42555         ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42556         ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42557         ZEND_JMPZ_EX_SPEC_CV_HANDLER,
42558         ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42559         ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42560         ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42561         ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42562         ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
42563         ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42564         ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42565         ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42566         ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42567         ZEND_JMPNZ_EX_SPEC_TMP_HANDLER,
42568         ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42569         ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42570         ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42571         ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42572         ZEND_JMPNZ_EX_SPEC_VAR_HANDLER,
42573         ZEND_NULL_HANDLER,
42574         ZEND_NULL_HANDLER,
42575         ZEND_NULL_HANDLER,
42576         ZEND_NULL_HANDLER,
42577         ZEND_NULL_HANDLER,
42578         ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42579         ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42580         ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42581         ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42582         ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
42583         ZEND_CASE_SPEC_CONST_CONST_HANDLER,
42584         ZEND_CASE_SPEC_CONST_TMP_HANDLER,
42585         ZEND_CASE_SPEC_CONST_VAR_HANDLER,
42586         ZEND_NULL_HANDLER,
42587         ZEND_CASE_SPEC_CONST_CV_HANDLER,
42588         ZEND_CASE_SPEC_TMP_CONST_HANDLER,
42589         ZEND_CASE_SPEC_TMP_TMP_HANDLER,
42590         ZEND_CASE_SPEC_TMP_VAR_HANDLER,
42591         ZEND_NULL_HANDLER,
42592         ZEND_CASE_SPEC_TMP_CV_HANDLER,
42593         ZEND_CASE_SPEC_VAR_CONST_HANDLER,
42594         ZEND_CASE_SPEC_VAR_TMP_HANDLER,
42595         ZEND_CASE_SPEC_VAR_VAR_HANDLER,
42596         ZEND_NULL_HANDLER,
42597         ZEND_CASE_SPEC_VAR_CV_HANDLER,
42598         ZEND_NULL_HANDLER,
42599         ZEND_NULL_HANDLER,
42600         ZEND_NULL_HANDLER,
42601         ZEND_NULL_HANDLER,
42602         ZEND_NULL_HANDLER,
42603         ZEND_CASE_SPEC_CV_CONST_HANDLER,
42604         ZEND_CASE_SPEC_CV_TMP_HANDLER,
42605         ZEND_CASE_SPEC_CV_VAR_HANDLER,
42606         ZEND_NULL_HANDLER,
42607         ZEND_CASE_SPEC_CV_CV_HANDLER,
42608         ZEND_NULL_HANDLER,
42609         ZEND_NULL_HANDLER,
42610         ZEND_NULL_HANDLER,
42611         ZEND_NULL_HANDLER,
42612         ZEND_NULL_HANDLER,
42613         ZEND_NULL_HANDLER,
42614         ZEND_NULL_HANDLER,
42615         ZEND_NULL_HANDLER,
42616         ZEND_NULL_HANDLER,
42617         ZEND_NULL_HANDLER,
42618         ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42619         ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42620         ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42621         ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42622         ZEND_SWITCH_FREE_SPEC_VAR_HANDLER,
42623         ZEND_NULL_HANDLER,
42624         ZEND_NULL_HANDLER,
42625         ZEND_NULL_HANDLER,
42626         ZEND_NULL_HANDLER,
42627         ZEND_NULL_HANDLER,
42628         ZEND_NULL_HANDLER,
42629         ZEND_NULL_HANDLER,
42630         ZEND_NULL_HANDLER,
42631         ZEND_NULL_HANDLER,
42632         ZEND_NULL_HANDLER,
42633         ZEND_BRK_SPEC_CONST_HANDLER,
42634         ZEND_NULL_HANDLER,
42635         ZEND_NULL_HANDLER,
42636         ZEND_NULL_HANDLER,
42637         ZEND_NULL_HANDLER,
42638         ZEND_BRK_SPEC_CONST_HANDLER,
42639         ZEND_NULL_HANDLER,
42640         ZEND_NULL_HANDLER,
42641         ZEND_NULL_HANDLER,
42642         ZEND_NULL_HANDLER,
42643         ZEND_BRK_SPEC_CONST_HANDLER,
42644         ZEND_NULL_HANDLER,
42645         ZEND_NULL_HANDLER,
42646         ZEND_NULL_HANDLER,
42647         ZEND_NULL_HANDLER,
42648         ZEND_BRK_SPEC_CONST_HANDLER,
42649         ZEND_NULL_HANDLER,
42650         ZEND_NULL_HANDLER,
42651         ZEND_NULL_HANDLER,
42652         ZEND_NULL_HANDLER,
42653         ZEND_BRK_SPEC_CONST_HANDLER,
42654         ZEND_NULL_HANDLER,
42655         ZEND_NULL_HANDLER,
42656         ZEND_NULL_HANDLER,
42657         ZEND_NULL_HANDLER,
42658         ZEND_CONT_SPEC_CONST_HANDLER,
42659         ZEND_NULL_HANDLER,
42660         ZEND_NULL_HANDLER,
42661         ZEND_NULL_HANDLER,
42662         ZEND_NULL_HANDLER,
42663         ZEND_CONT_SPEC_CONST_HANDLER,
42664         ZEND_NULL_HANDLER,
42665         ZEND_NULL_HANDLER,
42666         ZEND_NULL_HANDLER,
42667         ZEND_NULL_HANDLER,
42668         ZEND_CONT_SPEC_CONST_HANDLER,
42669         ZEND_NULL_HANDLER,
42670         ZEND_NULL_HANDLER,
42671         ZEND_NULL_HANDLER,
42672         ZEND_NULL_HANDLER,
42673         ZEND_CONT_SPEC_CONST_HANDLER,
42674         ZEND_NULL_HANDLER,
42675         ZEND_NULL_HANDLER,
42676         ZEND_NULL_HANDLER,
42677         ZEND_NULL_HANDLER,
42678         ZEND_CONT_SPEC_CONST_HANDLER,
42679         ZEND_NULL_HANDLER,
42680         ZEND_NULL_HANDLER,
42681         ZEND_NULL_HANDLER,
42682         ZEND_NULL_HANDLER,
42683         ZEND_BOOL_SPEC_CONST_HANDLER,
42684         ZEND_BOOL_SPEC_CONST_HANDLER,
42685         ZEND_BOOL_SPEC_CONST_HANDLER,
42686         ZEND_BOOL_SPEC_CONST_HANDLER,
42687         ZEND_BOOL_SPEC_CONST_HANDLER,
42688         ZEND_BOOL_SPEC_TMP_HANDLER,
42689         ZEND_BOOL_SPEC_TMP_HANDLER,
42690         ZEND_BOOL_SPEC_TMP_HANDLER,
42691         ZEND_BOOL_SPEC_TMP_HANDLER,
42692         ZEND_BOOL_SPEC_TMP_HANDLER,
42693         ZEND_BOOL_SPEC_VAR_HANDLER,
42694         ZEND_BOOL_SPEC_VAR_HANDLER,
42695         ZEND_BOOL_SPEC_VAR_HANDLER,
42696         ZEND_BOOL_SPEC_VAR_HANDLER,
42697         ZEND_BOOL_SPEC_VAR_HANDLER,
42698         ZEND_NULL_HANDLER,
42699         ZEND_NULL_HANDLER,
42700         ZEND_NULL_HANDLER,
42701         ZEND_NULL_HANDLER,
42702         ZEND_NULL_HANDLER,
42703         ZEND_BOOL_SPEC_CV_HANDLER,
42704         ZEND_BOOL_SPEC_CV_HANDLER,
42705         ZEND_BOOL_SPEC_CV_HANDLER,
42706         ZEND_BOOL_SPEC_CV_HANDLER,
42707         ZEND_BOOL_SPEC_CV_HANDLER,
42708         ZEND_INIT_STRING_SPEC_HANDLER,
42709         ZEND_INIT_STRING_SPEC_HANDLER,
42710         ZEND_INIT_STRING_SPEC_HANDLER,
42711         ZEND_INIT_STRING_SPEC_HANDLER,
42712         ZEND_INIT_STRING_SPEC_HANDLER,
42713         ZEND_INIT_STRING_SPEC_HANDLER,
42714         ZEND_INIT_STRING_SPEC_HANDLER,
42715         ZEND_INIT_STRING_SPEC_HANDLER,
42716         ZEND_INIT_STRING_SPEC_HANDLER,
42717         ZEND_INIT_STRING_SPEC_HANDLER,
42718         ZEND_INIT_STRING_SPEC_HANDLER,
42719         ZEND_INIT_STRING_SPEC_HANDLER,
42720         ZEND_INIT_STRING_SPEC_HANDLER,
42721         ZEND_INIT_STRING_SPEC_HANDLER,
42722         ZEND_INIT_STRING_SPEC_HANDLER,
42723         ZEND_INIT_STRING_SPEC_HANDLER,
42724         ZEND_INIT_STRING_SPEC_HANDLER,
42725         ZEND_INIT_STRING_SPEC_HANDLER,
42726         ZEND_INIT_STRING_SPEC_HANDLER,
42727         ZEND_INIT_STRING_SPEC_HANDLER,
42728         ZEND_INIT_STRING_SPEC_HANDLER,
42729         ZEND_INIT_STRING_SPEC_HANDLER,
42730         ZEND_INIT_STRING_SPEC_HANDLER,
42731         ZEND_INIT_STRING_SPEC_HANDLER,
42732         ZEND_INIT_STRING_SPEC_HANDLER,
42733         ZEND_NULL_HANDLER,
42734         ZEND_NULL_HANDLER,
42735         ZEND_NULL_HANDLER,
42736         ZEND_NULL_HANDLER,
42737         ZEND_NULL_HANDLER,
42738         ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER,
42739         ZEND_NULL_HANDLER,
42740         ZEND_NULL_HANDLER,
42741         ZEND_NULL_HANDLER,
42742         ZEND_NULL_HANDLER,
42743         ZEND_NULL_HANDLER,
42744         ZEND_NULL_HANDLER,
42745         ZEND_NULL_HANDLER,
42746         ZEND_NULL_HANDLER,
42747         ZEND_NULL_HANDLER,
42748         ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER,
42749         ZEND_NULL_HANDLER,
42750         ZEND_NULL_HANDLER,
42751         ZEND_NULL_HANDLER,
42752         ZEND_NULL_HANDLER,
42753         ZEND_NULL_HANDLER,
42754         ZEND_NULL_HANDLER,
42755         ZEND_NULL_HANDLER,
42756         ZEND_NULL_HANDLER,
42757         ZEND_NULL_HANDLER,
42758         ZEND_NULL_HANDLER,
42759         ZEND_NULL_HANDLER,
42760         ZEND_NULL_HANDLER,
42761         ZEND_NULL_HANDLER,
42762         ZEND_NULL_HANDLER,
42763         ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER,
42764         ZEND_NULL_HANDLER,
42765         ZEND_NULL_HANDLER,
42766         ZEND_NULL_HANDLER,
42767         ZEND_NULL_HANDLER,
42768         ZEND_NULL_HANDLER,
42769         ZEND_NULL_HANDLER,
42770         ZEND_NULL_HANDLER,
42771         ZEND_NULL_HANDLER,
42772         ZEND_NULL_HANDLER,
42773         ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER,
42774         ZEND_NULL_HANDLER,
42775         ZEND_NULL_HANDLER,
42776         ZEND_NULL_HANDLER,
42777         ZEND_NULL_HANDLER,
42778         ZEND_NULL_HANDLER,
42779         ZEND_NULL_HANDLER,
42780         ZEND_NULL_HANDLER,
42781         ZEND_NULL_HANDLER,
42782         ZEND_NULL_HANDLER,
42783         ZEND_NULL_HANDLER,
42784         ZEND_NULL_HANDLER,
42785         ZEND_NULL_HANDLER,
42786         ZEND_NULL_HANDLER,
42787         ZEND_NULL_HANDLER,
42788         ZEND_NULL_HANDLER,
42789         ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER,
42790         ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER,
42791         ZEND_NULL_HANDLER,
42792         ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER,
42793         ZEND_NULL_HANDLER,
42794         ZEND_NULL_HANDLER,
42795         ZEND_NULL_HANDLER,
42796         ZEND_NULL_HANDLER,
42797         ZEND_NULL_HANDLER,
42798         ZEND_NULL_HANDLER,
42799         ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER,
42800         ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER,
42801         ZEND_NULL_HANDLER,
42802         ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER,
42803         ZEND_NULL_HANDLER,
42804         ZEND_NULL_HANDLER,
42805         ZEND_NULL_HANDLER,
42806         ZEND_NULL_HANDLER,
42807         ZEND_NULL_HANDLER,
42808         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42809         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42810         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42811         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42812         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42813         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42814         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42815         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42816         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42817         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42818         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42819         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42820         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42821         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42822         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42823         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42824         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42825         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42826         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42827         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42828         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42829         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42830         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42831         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42832         ZEND_BEGIN_SILENCE_SPEC_HANDLER,
42833         ZEND_NULL_HANDLER,
42834         ZEND_NULL_HANDLER,
42835         ZEND_NULL_HANDLER,
42836         ZEND_NULL_HANDLER,
42837         ZEND_NULL_HANDLER,
42838         ZEND_END_SILENCE_SPEC_TMP_HANDLER,
42839         ZEND_END_SILENCE_SPEC_TMP_HANDLER,
42840         ZEND_END_SILENCE_SPEC_TMP_HANDLER,
42841         ZEND_END_SILENCE_SPEC_TMP_HANDLER,
42842         ZEND_END_SILENCE_SPEC_TMP_HANDLER,
42843         ZEND_NULL_HANDLER,
42844         ZEND_NULL_HANDLER,
42845         ZEND_NULL_HANDLER,
42846         ZEND_NULL_HANDLER,
42847         ZEND_NULL_HANDLER,
42848         ZEND_NULL_HANDLER,
42849         ZEND_NULL_HANDLER,
42850         ZEND_NULL_HANDLER,
42851         ZEND_NULL_HANDLER,
42852         ZEND_NULL_HANDLER,
42853         ZEND_NULL_HANDLER,
42854         ZEND_NULL_HANDLER,
42855         ZEND_NULL_HANDLER,
42856         ZEND_NULL_HANDLER,
42857         ZEND_NULL_HANDLER,
42858         ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
42859         ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
42860         ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
42861         ZEND_NULL_HANDLER,
42862         ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
42863         ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
42864         ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
42865         ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
42866         ZEND_NULL_HANDLER,
42867         ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
42868         ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
42869         ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
42870         ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
42871         ZEND_NULL_HANDLER,
42872         ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
42873         ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
42874         ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
42875         ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
42876         ZEND_NULL_HANDLER,
42877         ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
42878         ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
42879         ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER,
42880         ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER,
42881         ZEND_NULL_HANDLER,
42882         ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER,
42883         ZEND_DO_FCALL_SPEC_CONST_HANDLER,
42884         ZEND_DO_FCALL_SPEC_CONST_HANDLER,
42885         ZEND_DO_FCALL_SPEC_CONST_HANDLER,
42886         ZEND_DO_FCALL_SPEC_CONST_HANDLER,
42887         ZEND_DO_FCALL_SPEC_CONST_HANDLER,
42888         ZEND_NULL_HANDLER,
42889         ZEND_NULL_HANDLER,
42890         ZEND_NULL_HANDLER,
42891         ZEND_NULL_HANDLER,
42892         ZEND_NULL_HANDLER,
42893         ZEND_NULL_HANDLER,
42894         ZEND_NULL_HANDLER,
42895         ZEND_NULL_HANDLER,
42896         ZEND_NULL_HANDLER,
42897         ZEND_NULL_HANDLER,
42898         ZEND_NULL_HANDLER,
42899         ZEND_NULL_HANDLER,
42900         ZEND_NULL_HANDLER,
42901         ZEND_NULL_HANDLER,
42902         ZEND_NULL_HANDLER,
42903         ZEND_NULL_HANDLER,
42904         ZEND_NULL_HANDLER,
42905         ZEND_NULL_HANDLER,
42906         ZEND_NULL_HANDLER,
42907         ZEND_NULL_HANDLER,
42908         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42909         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42910         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42911         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42912         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42913         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42914         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42915         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42916         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42917         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42918         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42919         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42920         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42921         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42922         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42923         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42924         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42925         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42926         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42927         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42928         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42929         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42930         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42931         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42932         ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER,
42933         ZEND_RETURN_SPEC_CONST_HANDLER,
42934         ZEND_RETURN_SPEC_CONST_HANDLER,
42935         ZEND_RETURN_SPEC_CONST_HANDLER,
42936         ZEND_RETURN_SPEC_CONST_HANDLER,
42937         ZEND_RETURN_SPEC_CONST_HANDLER,
42938         ZEND_RETURN_SPEC_TMP_HANDLER,
42939         ZEND_RETURN_SPEC_TMP_HANDLER,
42940         ZEND_RETURN_SPEC_TMP_HANDLER,
42941         ZEND_RETURN_SPEC_TMP_HANDLER,
42942         ZEND_RETURN_SPEC_TMP_HANDLER,
42943         ZEND_RETURN_SPEC_VAR_HANDLER,
42944         ZEND_RETURN_SPEC_VAR_HANDLER,
42945         ZEND_RETURN_SPEC_VAR_HANDLER,
42946         ZEND_RETURN_SPEC_VAR_HANDLER,
42947         ZEND_RETURN_SPEC_VAR_HANDLER,
42948         ZEND_NULL_HANDLER,
42949         ZEND_NULL_HANDLER,
42950         ZEND_NULL_HANDLER,
42951         ZEND_NULL_HANDLER,
42952         ZEND_NULL_HANDLER,
42953         ZEND_RETURN_SPEC_CV_HANDLER,
42954         ZEND_RETURN_SPEC_CV_HANDLER,
42955         ZEND_RETURN_SPEC_CV_HANDLER,
42956         ZEND_RETURN_SPEC_CV_HANDLER,
42957         ZEND_RETURN_SPEC_CV_HANDLER,
42958         ZEND_RECV_SPEC_HANDLER,
42959         ZEND_RECV_SPEC_HANDLER,
42960         ZEND_RECV_SPEC_HANDLER,
42961         ZEND_RECV_SPEC_HANDLER,
42962         ZEND_RECV_SPEC_HANDLER,
42963         ZEND_RECV_SPEC_HANDLER,
42964         ZEND_RECV_SPEC_HANDLER,
42965         ZEND_RECV_SPEC_HANDLER,
42966         ZEND_RECV_SPEC_HANDLER,
42967         ZEND_RECV_SPEC_HANDLER,
42968         ZEND_RECV_SPEC_HANDLER,
42969         ZEND_RECV_SPEC_HANDLER,
42970         ZEND_RECV_SPEC_HANDLER,
42971         ZEND_RECV_SPEC_HANDLER,
42972         ZEND_RECV_SPEC_HANDLER,
42973         ZEND_RECV_SPEC_HANDLER,
42974         ZEND_RECV_SPEC_HANDLER,
42975         ZEND_RECV_SPEC_HANDLER,
42976         ZEND_RECV_SPEC_HANDLER,
42977         ZEND_RECV_SPEC_HANDLER,
42978         ZEND_RECV_SPEC_HANDLER,
42979         ZEND_RECV_SPEC_HANDLER,
42980         ZEND_RECV_SPEC_HANDLER,
42981         ZEND_RECV_SPEC_HANDLER,
42982         ZEND_RECV_SPEC_HANDLER,
42983         ZEND_RECV_INIT_SPEC_CONST_HANDLER,
42984         ZEND_NULL_HANDLER,
42985         ZEND_NULL_HANDLER,
42986         ZEND_NULL_HANDLER,
42987         ZEND_NULL_HANDLER,
42988         ZEND_RECV_INIT_SPEC_CONST_HANDLER,
42989         ZEND_NULL_HANDLER,
42990         ZEND_NULL_HANDLER,
42991         ZEND_NULL_HANDLER,
42992         ZEND_NULL_HANDLER,
42993         ZEND_RECV_INIT_SPEC_CONST_HANDLER,
42994         ZEND_NULL_HANDLER,
42995         ZEND_NULL_HANDLER,
42996         ZEND_NULL_HANDLER,
42997         ZEND_NULL_HANDLER,
42998         ZEND_RECV_INIT_SPEC_CONST_HANDLER,
42999         ZEND_NULL_HANDLER,
43000         ZEND_NULL_HANDLER,
43001         ZEND_NULL_HANDLER,
43002         ZEND_NULL_HANDLER,
43003         ZEND_RECV_INIT_SPEC_CONST_HANDLER,
43004         ZEND_NULL_HANDLER,
43005         ZEND_NULL_HANDLER,
43006         ZEND_NULL_HANDLER,
43007         ZEND_NULL_HANDLER,
43008         ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43009         ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43010         ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43011         ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43012         ZEND_SEND_VAL_SPEC_CONST_HANDLER,
43013         ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43014         ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43015         ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43016         ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43017         ZEND_SEND_VAL_SPEC_TMP_HANDLER,
43018         ZEND_NULL_HANDLER,
43019         ZEND_NULL_HANDLER,
43020         ZEND_NULL_HANDLER,
43021         ZEND_NULL_HANDLER,
43022         ZEND_NULL_HANDLER,
43023         ZEND_NULL_HANDLER,
43024         ZEND_NULL_HANDLER,
43025         ZEND_NULL_HANDLER,
43026         ZEND_NULL_HANDLER,
43027         ZEND_NULL_HANDLER,
43028         ZEND_NULL_HANDLER,
43029         ZEND_NULL_HANDLER,
43030         ZEND_NULL_HANDLER,
43031         ZEND_NULL_HANDLER,
43032         ZEND_NULL_HANDLER,
43033         ZEND_NULL_HANDLER,
43034         ZEND_NULL_HANDLER,
43035         ZEND_NULL_HANDLER,
43036         ZEND_NULL_HANDLER,
43037         ZEND_NULL_HANDLER,
43038         ZEND_NULL_HANDLER,
43039         ZEND_NULL_HANDLER,
43040         ZEND_NULL_HANDLER,
43041         ZEND_NULL_HANDLER,
43042         ZEND_NULL_HANDLER,
43043         ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43044         ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43045         ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43046         ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43047         ZEND_SEND_VAR_SPEC_VAR_HANDLER,
43048         ZEND_NULL_HANDLER,
43049         ZEND_NULL_HANDLER,
43050         ZEND_NULL_HANDLER,
43051         ZEND_NULL_HANDLER,
43052         ZEND_NULL_HANDLER,
43053         ZEND_SEND_VAR_SPEC_CV_HANDLER,
43054         ZEND_SEND_VAR_SPEC_CV_HANDLER,
43055         ZEND_SEND_VAR_SPEC_CV_HANDLER,
43056         ZEND_SEND_VAR_SPEC_CV_HANDLER,
43057         ZEND_SEND_VAR_SPEC_CV_HANDLER,
43058         ZEND_NULL_HANDLER,
43059         ZEND_NULL_HANDLER,
43060         ZEND_NULL_HANDLER,
43061         ZEND_NULL_HANDLER,
43062         ZEND_NULL_HANDLER,
43063         ZEND_NULL_HANDLER,
43064         ZEND_NULL_HANDLER,
43065         ZEND_NULL_HANDLER,
43066         ZEND_NULL_HANDLER,
43067         ZEND_NULL_HANDLER,
43068         ZEND_SEND_REF_SPEC_VAR_HANDLER,
43069         ZEND_SEND_REF_SPEC_VAR_HANDLER,
43070         ZEND_SEND_REF_SPEC_VAR_HANDLER,
43071         ZEND_SEND_REF_SPEC_VAR_HANDLER,
43072         ZEND_SEND_REF_SPEC_VAR_HANDLER,
43073         ZEND_NULL_HANDLER,
43074         ZEND_NULL_HANDLER,
43075         ZEND_NULL_HANDLER,
43076         ZEND_NULL_HANDLER,
43077         ZEND_NULL_HANDLER,
43078         ZEND_SEND_REF_SPEC_CV_HANDLER,
43079         ZEND_SEND_REF_SPEC_CV_HANDLER,
43080         ZEND_SEND_REF_SPEC_CV_HANDLER,
43081         ZEND_SEND_REF_SPEC_CV_HANDLER,
43082         ZEND_SEND_REF_SPEC_CV_HANDLER,
43083         ZEND_NEW_SPEC_HANDLER,
43084         ZEND_NEW_SPEC_HANDLER,
43085         ZEND_NEW_SPEC_HANDLER,
43086         ZEND_NEW_SPEC_HANDLER,
43087         ZEND_NEW_SPEC_HANDLER,
43088         ZEND_NEW_SPEC_HANDLER,
43089         ZEND_NEW_SPEC_HANDLER,
43090         ZEND_NEW_SPEC_HANDLER,
43091         ZEND_NEW_SPEC_HANDLER,
43092         ZEND_NEW_SPEC_HANDLER,
43093         ZEND_NEW_SPEC_HANDLER,
43094         ZEND_NEW_SPEC_HANDLER,
43095         ZEND_NEW_SPEC_HANDLER,
43096         ZEND_NEW_SPEC_HANDLER,
43097         ZEND_NEW_SPEC_HANDLER,
43098         ZEND_NEW_SPEC_HANDLER,
43099         ZEND_NEW_SPEC_HANDLER,
43100         ZEND_NEW_SPEC_HANDLER,
43101         ZEND_NEW_SPEC_HANDLER,
43102         ZEND_NEW_SPEC_HANDLER,
43103         ZEND_NEW_SPEC_HANDLER,
43104         ZEND_NEW_SPEC_HANDLER,
43105         ZEND_NEW_SPEC_HANDLER,
43106         ZEND_NEW_SPEC_HANDLER,
43107         ZEND_NEW_SPEC_HANDLER,
43108         ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43109         ZEND_NULL_HANDLER,
43110         ZEND_NULL_HANDLER,
43111         ZEND_NULL_HANDLER,
43112         ZEND_NULL_HANDLER,
43113         ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43114         ZEND_NULL_HANDLER,
43115         ZEND_NULL_HANDLER,
43116         ZEND_NULL_HANDLER,
43117         ZEND_NULL_HANDLER,
43118         ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43119         ZEND_NULL_HANDLER,
43120         ZEND_NULL_HANDLER,
43121         ZEND_NULL_HANDLER,
43122         ZEND_NULL_HANDLER,
43123         ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43124         ZEND_NULL_HANDLER,
43125         ZEND_NULL_HANDLER,
43126         ZEND_NULL_HANDLER,
43127         ZEND_NULL_HANDLER,
43128         ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
43129         ZEND_NULL_HANDLER,
43130         ZEND_NULL_HANDLER,
43131         ZEND_NULL_HANDLER,
43132         ZEND_NULL_HANDLER,
43133         ZEND_NULL_HANDLER,
43134         ZEND_NULL_HANDLER,
43135         ZEND_NULL_HANDLER,
43136         ZEND_NULL_HANDLER,
43137         ZEND_NULL_HANDLER,
43138         ZEND_FREE_SPEC_TMP_HANDLER,
43139         ZEND_FREE_SPEC_TMP_HANDLER,
43140         ZEND_FREE_SPEC_TMP_HANDLER,
43141         ZEND_FREE_SPEC_TMP_HANDLER,
43142         ZEND_FREE_SPEC_TMP_HANDLER,
43143         ZEND_FREE_SPEC_VAR_HANDLER,
43144         ZEND_FREE_SPEC_VAR_HANDLER,
43145         ZEND_FREE_SPEC_VAR_HANDLER,
43146         ZEND_FREE_SPEC_VAR_HANDLER,
43147         ZEND_FREE_SPEC_VAR_HANDLER,
43148         ZEND_NULL_HANDLER,
43149         ZEND_NULL_HANDLER,
43150         ZEND_NULL_HANDLER,
43151         ZEND_NULL_HANDLER,
43152         ZEND_NULL_HANDLER,
43153         ZEND_NULL_HANDLER,
43154         ZEND_NULL_HANDLER,
43155         ZEND_NULL_HANDLER,
43156         ZEND_NULL_HANDLER,
43157         ZEND_NULL_HANDLER,
43158         ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
43159         ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER,
43160         ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER,
43161         ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
43162         ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
43163         ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
43164         ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER,
43165         ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER,
43166         ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
43167         ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
43168         ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
43169         ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER,
43170         ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER,
43171         ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
43172         ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
43173         ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
43174         ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER,
43175         ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER,
43176         ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
43177         ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
43178         ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
43179         ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER,
43180         ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER,
43181         ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
43182         ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
43183         ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
43184         ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER,
43185         ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER,
43186         ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
43187         ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
43188         ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
43189         ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER,
43190         ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER,
43191         ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
43192         ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
43193         ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
43194         ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER,
43195         ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER,
43196         ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
43197         ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
43198         ZEND_NULL_HANDLER,
43199         ZEND_NULL_HANDLER,
43200         ZEND_NULL_HANDLER,
43201         ZEND_NULL_HANDLER,
43202         ZEND_NULL_HANDLER,
43203         ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
43204         ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER,
43205         ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER,
43206         ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
43207         ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
43208         ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43209         ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43210         ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43211         ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43212         ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
43213         ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43214         ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43215         ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43216         ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43217         ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER,
43218         ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43219         ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43220         ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43221         ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43222         ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER,
43223         ZEND_NULL_HANDLER,
43224         ZEND_NULL_HANDLER,
43225         ZEND_NULL_HANDLER,
43226         ZEND_NULL_HANDLER,
43227         ZEND_NULL_HANDLER,
43228         ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43229         ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43230         ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43231         ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43232         ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
43233         ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER,
43234         ZEND_NULL_HANDLER,
43235         ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER,
43236         ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
43237         ZEND_NULL_HANDLER,
43238         ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER,
43239         ZEND_NULL_HANDLER,
43240         ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER,
43241         ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER,
43242         ZEND_NULL_HANDLER,
43243         ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER,
43244         ZEND_NULL_HANDLER,
43245         ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER,
43246         ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER,
43247         ZEND_NULL_HANDLER,
43248         ZEND_NULL_HANDLER,
43249         ZEND_NULL_HANDLER,
43250         ZEND_NULL_HANDLER,
43251         ZEND_NULL_HANDLER,
43252         ZEND_NULL_HANDLER,
43253         ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER,
43254         ZEND_NULL_HANDLER,
43255         ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER,
43256         ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
43257         ZEND_NULL_HANDLER,
43258         ZEND_NULL_HANDLER,
43259         ZEND_NULL_HANDLER,
43260         ZEND_NULL_HANDLER,
43261         ZEND_NULL_HANDLER,
43262         ZEND_NULL_HANDLER,
43263         ZEND_NULL_HANDLER,
43264         ZEND_NULL_HANDLER,
43265         ZEND_NULL_HANDLER,
43266         ZEND_NULL_HANDLER,
43267         ZEND_NULL_HANDLER,
43268         ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
43269         ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER,
43270         ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER,
43271         ZEND_NULL_HANDLER,
43272         ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
43273         ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER,
43274         ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER,
43275         ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER,
43276         ZEND_NULL_HANDLER,
43277         ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER,
43278         ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
43279         ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER,
43280         ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER,
43281         ZEND_NULL_HANDLER,
43282         ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
43283         ZEND_NULL_HANDLER,
43284         ZEND_NULL_HANDLER,
43285         ZEND_NULL_HANDLER,
43286         ZEND_NULL_HANDLER,
43287         ZEND_NULL_HANDLER,
43288         ZEND_NULL_HANDLER,
43289         ZEND_NULL_HANDLER,
43290         ZEND_NULL_HANDLER,
43291         ZEND_NULL_HANDLER,
43292         ZEND_NULL_HANDLER,
43293         ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
43294         ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER,
43295         ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER,
43296         ZEND_NULL_HANDLER,
43297         ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
43298         ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
43299         ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER,
43300         ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER,
43301         ZEND_NULL_HANDLER,
43302         ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
43303         ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
43304         ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER,
43305         ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER,
43306         ZEND_NULL_HANDLER,
43307         ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
43308         ZEND_FE_RESET_SPEC_CONST_HANDLER,
43309         ZEND_FE_RESET_SPEC_CONST_HANDLER,
43310         ZEND_FE_RESET_SPEC_CONST_HANDLER,
43311         ZEND_FE_RESET_SPEC_CONST_HANDLER,
43312         ZEND_FE_RESET_SPEC_CONST_HANDLER,
43313         ZEND_FE_RESET_SPEC_TMP_HANDLER,
43314         ZEND_FE_RESET_SPEC_TMP_HANDLER,
43315         ZEND_FE_RESET_SPEC_TMP_HANDLER,
43316         ZEND_FE_RESET_SPEC_TMP_HANDLER,
43317         ZEND_FE_RESET_SPEC_TMP_HANDLER,
43318         ZEND_FE_RESET_SPEC_VAR_HANDLER,
43319         ZEND_FE_RESET_SPEC_VAR_HANDLER,
43320         ZEND_FE_RESET_SPEC_VAR_HANDLER,
43321         ZEND_FE_RESET_SPEC_VAR_HANDLER,
43322         ZEND_FE_RESET_SPEC_VAR_HANDLER,
43323         ZEND_NULL_HANDLER,
43324         ZEND_NULL_HANDLER,
43325         ZEND_NULL_HANDLER,
43326         ZEND_NULL_HANDLER,
43327         ZEND_NULL_HANDLER,
43328         ZEND_FE_RESET_SPEC_CV_HANDLER,
43329         ZEND_FE_RESET_SPEC_CV_HANDLER,
43330         ZEND_FE_RESET_SPEC_CV_HANDLER,
43331         ZEND_FE_RESET_SPEC_CV_HANDLER,
43332         ZEND_FE_RESET_SPEC_CV_HANDLER,
43333         ZEND_NULL_HANDLER,
43334         ZEND_NULL_HANDLER,
43335         ZEND_NULL_HANDLER,
43336         ZEND_NULL_HANDLER,
43337         ZEND_NULL_HANDLER,
43338         ZEND_NULL_HANDLER,
43339         ZEND_NULL_HANDLER,
43340         ZEND_NULL_HANDLER,
43341         ZEND_NULL_HANDLER,
43342         ZEND_NULL_HANDLER,
43343         ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43344         ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43345         ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43346         ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43347         ZEND_FE_FETCH_SPEC_VAR_HANDLER,
43348         ZEND_NULL_HANDLER,
43349         ZEND_NULL_HANDLER,
43350         ZEND_NULL_HANDLER,
43351         ZEND_NULL_HANDLER,
43352         ZEND_NULL_HANDLER,
43353         ZEND_NULL_HANDLER,
43354         ZEND_NULL_HANDLER,
43355         ZEND_NULL_HANDLER,
43356         ZEND_NULL_HANDLER,
43357         ZEND_NULL_HANDLER,
43358         ZEND_EXIT_SPEC_CONST_HANDLER,
43359         ZEND_EXIT_SPEC_CONST_HANDLER,
43360         ZEND_EXIT_SPEC_CONST_HANDLER,
43361         ZEND_EXIT_SPEC_CONST_HANDLER,
43362         ZEND_EXIT_SPEC_CONST_HANDLER,
43363         ZEND_EXIT_SPEC_TMP_HANDLER,
43364         ZEND_EXIT_SPEC_TMP_HANDLER,
43365         ZEND_EXIT_SPEC_TMP_HANDLER,
43366         ZEND_EXIT_SPEC_TMP_HANDLER,
43367         ZEND_EXIT_SPEC_TMP_HANDLER,
43368         ZEND_EXIT_SPEC_VAR_HANDLER,
43369         ZEND_EXIT_SPEC_VAR_HANDLER,
43370         ZEND_EXIT_SPEC_VAR_HANDLER,
43371         ZEND_EXIT_SPEC_VAR_HANDLER,
43372         ZEND_EXIT_SPEC_VAR_HANDLER,
43373         ZEND_EXIT_SPEC_UNUSED_HANDLER,
43374         ZEND_EXIT_SPEC_UNUSED_HANDLER,
43375         ZEND_EXIT_SPEC_UNUSED_HANDLER,
43376         ZEND_EXIT_SPEC_UNUSED_HANDLER,
43377         ZEND_EXIT_SPEC_UNUSED_HANDLER,
43378         ZEND_EXIT_SPEC_CV_HANDLER,
43379         ZEND_EXIT_SPEC_CV_HANDLER,
43380         ZEND_EXIT_SPEC_CV_HANDLER,
43381         ZEND_EXIT_SPEC_CV_HANDLER,
43382         ZEND_EXIT_SPEC_CV_HANDLER,
43383         ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER,
43384         ZEND_NULL_HANDLER,
43385         ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER,
43386         ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
43387         ZEND_NULL_HANDLER,
43388         ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER,
43389         ZEND_NULL_HANDLER,
43390         ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER,
43391         ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER,
43392         ZEND_NULL_HANDLER,
43393         ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER,
43394         ZEND_NULL_HANDLER,
43395         ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER,
43396         ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER,
43397         ZEND_NULL_HANDLER,
43398         ZEND_NULL_HANDLER,
43399         ZEND_NULL_HANDLER,
43400         ZEND_NULL_HANDLER,
43401         ZEND_NULL_HANDLER,
43402         ZEND_NULL_HANDLER,
43403         ZEND_FETCH_R_SPEC_CV_CONST_HANDLER,
43404         ZEND_NULL_HANDLER,
43405         ZEND_FETCH_R_SPEC_CV_VAR_HANDLER,
43406         ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
43407         ZEND_NULL_HANDLER,
43408         ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
43409         ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER,
43410         ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER,
43411         ZEND_NULL_HANDLER,
43412         ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
43413         ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER,
43414         ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER,
43415         ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER,
43416         ZEND_NULL_HANDLER,
43417         ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER,
43418         ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER,
43419         ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER,
43420         ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER,
43421         ZEND_NULL_HANDLER,
43422         ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER,
43423         ZEND_NULL_HANDLER,
43424         ZEND_NULL_HANDLER,
43425         ZEND_NULL_HANDLER,
43426         ZEND_NULL_HANDLER,
43427         ZEND_NULL_HANDLER,
43428         ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
43429         ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER,
43430         ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER,
43431         ZEND_NULL_HANDLER,
43432         ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
43433         ZEND_NULL_HANDLER,
43434         ZEND_NULL_HANDLER,
43435         ZEND_NULL_HANDLER,
43436         ZEND_NULL_HANDLER,
43437         ZEND_NULL_HANDLER,
43438         ZEND_NULL_HANDLER,
43439         ZEND_NULL_HANDLER,
43440         ZEND_NULL_HANDLER,
43441         ZEND_NULL_HANDLER,
43442         ZEND_NULL_HANDLER,
43443         ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER,
43444         ZEND_FETCH_OBJ_R_SPEC_VAR_TMP_HANDLER,
43445         ZEND_FETCH_OBJ_R_SPEC_VAR_VAR_HANDLER,
43446         ZEND_NULL_HANDLER,
43447         ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER,
43448         ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
43449         ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER,
43450         ZEND_FETCH_OBJ_R_SPEC_UNUSED_VAR_HANDLER,
43451         ZEND_NULL_HANDLER,
43452         ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
43453         ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
43454         ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER,
43455         ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER,
43456         ZEND_NULL_HANDLER,
43457         ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
43458         ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER,
43459         ZEND_NULL_HANDLER,
43460         ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER,
43461         ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
43462         ZEND_NULL_HANDLER,
43463         ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER,
43464         ZEND_NULL_HANDLER,
43465         ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER,
43466         ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER,
43467         ZEND_NULL_HANDLER,
43468         ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER,
43469         ZEND_NULL_HANDLER,
43470         ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER,
43471         ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER,
43472         ZEND_NULL_HANDLER,
43473         ZEND_NULL_HANDLER,
43474         ZEND_NULL_HANDLER,
43475         ZEND_NULL_HANDLER,
43476         ZEND_NULL_HANDLER,
43477         ZEND_NULL_HANDLER,
43478         ZEND_FETCH_W_SPEC_CV_CONST_HANDLER,
43479         ZEND_NULL_HANDLER,
43480         ZEND_FETCH_W_SPEC_CV_VAR_HANDLER,
43481         ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
43482         ZEND_NULL_HANDLER,
43483         ZEND_NULL_HANDLER,
43484         ZEND_NULL_HANDLER,
43485         ZEND_NULL_HANDLER,
43486         ZEND_NULL_HANDLER,
43487         ZEND_NULL_HANDLER,
43488         ZEND_NULL_HANDLER,
43489         ZEND_NULL_HANDLER,
43490         ZEND_NULL_HANDLER,
43491         ZEND_NULL_HANDLER,
43492         ZEND_NULL_HANDLER,
43493         ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
43494         ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER,
43495         ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER,
43496         ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
43497         ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
43498         ZEND_NULL_HANDLER,
43499         ZEND_NULL_HANDLER,
43500         ZEND_NULL_HANDLER,
43501         ZEND_NULL_HANDLER,
43502         ZEND_NULL_HANDLER,
43503         ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
43504         ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER,
43505         ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER,
43506         ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
43507         ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
43508         ZEND_NULL_HANDLER,
43509         ZEND_NULL_HANDLER,
43510         ZEND_NULL_HANDLER,
43511         ZEND_NULL_HANDLER,
43512         ZEND_NULL_HANDLER,
43513         ZEND_NULL_HANDLER,
43514         ZEND_NULL_HANDLER,
43515         ZEND_NULL_HANDLER,
43516         ZEND_NULL_HANDLER,
43517         ZEND_NULL_HANDLER,
43518         ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
43519         ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER,
43520         ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER,
43521         ZEND_NULL_HANDLER,
43522         ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
43523         ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
43524         ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER,
43525         ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER,
43526         ZEND_NULL_HANDLER,
43527         ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
43528         ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
43529         ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER,
43530         ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER,
43531         ZEND_NULL_HANDLER,
43532         ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
43533         ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER,
43534         ZEND_NULL_HANDLER,
43535         ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER,
43536         ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
43537         ZEND_NULL_HANDLER,
43538         ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER,
43539         ZEND_NULL_HANDLER,
43540         ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER,
43541         ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER,
43542         ZEND_NULL_HANDLER,
43543         ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER,
43544         ZEND_NULL_HANDLER,
43545         ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER,
43546         ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER,
43547         ZEND_NULL_HANDLER,
43548         ZEND_NULL_HANDLER,
43549         ZEND_NULL_HANDLER,
43550         ZEND_NULL_HANDLER,
43551         ZEND_NULL_HANDLER,
43552         ZEND_NULL_HANDLER,
43553         ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER,
43554         ZEND_NULL_HANDLER,
43555         ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER,
43556         ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
43557         ZEND_NULL_HANDLER,
43558         ZEND_NULL_HANDLER,
43559         ZEND_NULL_HANDLER,
43560         ZEND_NULL_HANDLER,
43561         ZEND_NULL_HANDLER,
43562         ZEND_NULL_HANDLER,
43563         ZEND_NULL_HANDLER,
43564         ZEND_NULL_HANDLER,
43565         ZEND_NULL_HANDLER,
43566         ZEND_NULL_HANDLER,
43567         ZEND_NULL_HANDLER,
43568         ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
43569         ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER,
43570         ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER,
43571         ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
43572         ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
43573         ZEND_NULL_HANDLER,
43574         ZEND_NULL_HANDLER,
43575         ZEND_NULL_HANDLER,
43576         ZEND_NULL_HANDLER,
43577         ZEND_NULL_HANDLER,
43578         ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
43579         ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER,
43580         ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER,
43581         ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
43582         ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
43583         ZEND_NULL_HANDLER,
43584         ZEND_NULL_HANDLER,
43585         ZEND_NULL_HANDLER,
43586         ZEND_NULL_HANDLER,
43587         ZEND_NULL_HANDLER,
43588         ZEND_NULL_HANDLER,
43589         ZEND_NULL_HANDLER,
43590         ZEND_NULL_HANDLER,
43591         ZEND_NULL_HANDLER,
43592         ZEND_NULL_HANDLER,
43593         ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
43594         ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER,
43595         ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER,
43596         ZEND_NULL_HANDLER,
43597         ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
43598         ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
43599         ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER,
43600         ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER,
43601         ZEND_NULL_HANDLER,
43602         ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
43603         ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
43604         ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER,
43605         ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER,
43606         ZEND_NULL_HANDLER,
43607         ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
43608         ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER,
43609         ZEND_NULL_HANDLER,
43610         ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER,
43611         ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
43612         ZEND_NULL_HANDLER,
43613         ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER,
43614         ZEND_NULL_HANDLER,
43615         ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER,
43616         ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER,
43617         ZEND_NULL_HANDLER,
43618         ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER,
43619         ZEND_NULL_HANDLER,
43620         ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER,
43621         ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER,
43622         ZEND_NULL_HANDLER,
43623         ZEND_NULL_HANDLER,
43624         ZEND_NULL_HANDLER,
43625         ZEND_NULL_HANDLER,
43626         ZEND_NULL_HANDLER,
43627         ZEND_NULL_HANDLER,
43628         ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER,
43629         ZEND_NULL_HANDLER,
43630         ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER,
43631         ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
43632         ZEND_NULL_HANDLER,
43633         ZEND_NULL_HANDLER,
43634         ZEND_NULL_HANDLER,
43635         ZEND_NULL_HANDLER,
43636         ZEND_NULL_HANDLER,
43637         ZEND_NULL_HANDLER,
43638         ZEND_NULL_HANDLER,
43639         ZEND_NULL_HANDLER,
43640         ZEND_NULL_HANDLER,
43641         ZEND_NULL_HANDLER,
43642         ZEND_NULL_HANDLER,
43643         ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER,
43644         ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER,
43645         ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER,
43646         ZEND_NULL_HANDLER,
43647         ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER,
43648         ZEND_NULL_HANDLER,
43649         ZEND_NULL_HANDLER,
43650         ZEND_NULL_HANDLER,
43651         ZEND_NULL_HANDLER,
43652         ZEND_NULL_HANDLER,
43653         ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
43654         ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER,
43655         ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER,
43656         ZEND_NULL_HANDLER,
43657         ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
43658         ZEND_NULL_HANDLER,
43659         ZEND_NULL_HANDLER,
43660         ZEND_NULL_HANDLER,
43661         ZEND_NULL_HANDLER,
43662         ZEND_NULL_HANDLER,
43663         ZEND_NULL_HANDLER,
43664         ZEND_NULL_HANDLER,
43665         ZEND_NULL_HANDLER,
43666         ZEND_NULL_HANDLER,
43667         ZEND_NULL_HANDLER,
43668         ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER,
43669         ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER,
43670         ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER,
43671         ZEND_NULL_HANDLER,
43672         ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER,
43673         ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
43674         ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER,
43675         ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER,
43676         ZEND_NULL_HANDLER,
43677         ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
43678         ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
43679         ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER,
43680         ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER,
43681         ZEND_NULL_HANDLER,
43682         ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
43683         ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
43684         ZEND_NULL_HANDLER,
43685         ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER,
43686         ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
43687         ZEND_NULL_HANDLER,
43688         ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
43689         ZEND_NULL_HANDLER,
43690         ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER,
43691         ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
43692         ZEND_NULL_HANDLER,
43693         ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
43694         ZEND_NULL_HANDLER,
43695         ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
43696         ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
43697         ZEND_NULL_HANDLER,
43698         ZEND_NULL_HANDLER,
43699         ZEND_NULL_HANDLER,
43700         ZEND_NULL_HANDLER,
43701         ZEND_NULL_HANDLER,
43702         ZEND_NULL_HANDLER,
43703         ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER,
43704         ZEND_NULL_HANDLER,
43705         ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER,
43706         ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
43707         ZEND_NULL_HANDLER,
43708         ZEND_NULL_HANDLER,
43709         ZEND_NULL_HANDLER,
43710         ZEND_NULL_HANDLER,
43711         ZEND_NULL_HANDLER,
43712         ZEND_NULL_HANDLER,
43713         ZEND_NULL_HANDLER,
43714         ZEND_NULL_HANDLER,
43715         ZEND_NULL_HANDLER,
43716         ZEND_NULL_HANDLER,
43717         ZEND_NULL_HANDLER,
43718         ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
43719         ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
43720         ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
43721         ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
43722         ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
43723         ZEND_NULL_HANDLER,
43724         ZEND_NULL_HANDLER,
43725         ZEND_NULL_HANDLER,
43726         ZEND_NULL_HANDLER,
43727         ZEND_NULL_HANDLER,
43728         ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
43729         ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER,
43730         ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER,
43731         ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
43732         ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
43733         ZEND_NULL_HANDLER,
43734         ZEND_NULL_HANDLER,
43735         ZEND_NULL_HANDLER,
43736         ZEND_NULL_HANDLER,
43737         ZEND_NULL_HANDLER,
43738         ZEND_NULL_HANDLER,
43739         ZEND_NULL_HANDLER,
43740         ZEND_NULL_HANDLER,
43741         ZEND_NULL_HANDLER,
43742         ZEND_NULL_HANDLER,
43743         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
43744         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
43745         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
43746         ZEND_NULL_HANDLER,
43747         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
43748         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
43749         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER,
43750         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER,
43751         ZEND_NULL_HANDLER,
43752         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
43753         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
43754         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER,
43755         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER,
43756         ZEND_NULL_HANDLER,
43757         ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
43758         ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER,
43759         ZEND_NULL_HANDLER,
43760         ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER,
43761         ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
43762         ZEND_NULL_HANDLER,
43763         ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER,
43764         ZEND_NULL_HANDLER,
43765         ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER,
43766         ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER,
43767         ZEND_NULL_HANDLER,
43768         ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER,
43769         ZEND_NULL_HANDLER,
43770         ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER,
43771         ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER,
43772         ZEND_NULL_HANDLER,
43773         ZEND_NULL_HANDLER,
43774         ZEND_NULL_HANDLER,
43775         ZEND_NULL_HANDLER,
43776         ZEND_NULL_HANDLER,
43777         ZEND_NULL_HANDLER,
43778         ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER,
43779         ZEND_NULL_HANDLER,
43780         ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER,
43781         ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
43782         ZEND_NULL_HANDLER,
43783         ZEND_NULL_HANDLER,
43784         ZEND_NULL_HANDLER,
43785         ZEND_NULL_HANDLER,
43786         ZEND_NULL_HANDLER,
43787         ZEND_NULL_HANDLER,
43788         ZEND_NULL_HANDLER,
43789         ZEND_NULL_HANDLER,
43790         ZEND_NULL_HANDLER,
43791         ZEND_NULL_HANDLER,
43792         ZEND_NULL_HANDLER,
43793         ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
43794         ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER,
43795         ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER,
43796         ZEND_NULL_HANDLER,
43797         ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
43798         ZEND_NULL_HANDLER,
43799         ZEND_NULL_HANDLER,
43800         ZEND_NULL_HANDLER,
43801         ZEND_NULL_HANDLER,
43802         ZEND_NULL_HANDLER,
43803         ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
43804         ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER,
43805         ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER,
43806         ZEND_NULL_HANDLER,
43807         ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
43808         ZEND_NULL_HANDLER,
43809         ZEND_NULL_HANDLER,
43810         ZEND_NULL_HANDLER,
43811         ZEND_NULL_HANDLER,
43812         ZEND_NULL_HANDLER,
43813         ZEND_NULL_HANDLER,
43814         ZEND_NULL_HANDLER,
43815         ZEND_NULL_HANDLER,
43816         ZEND_NULL_HANDLER,
43817         ZEND_NULL_HANDLER,
43818         ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
43819         ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER,
43820         ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER,
43821         ZEND_NULL_HANDLER,
43822         ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
43823         ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
43824         ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER,
43825         ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER,
43826         ZEND_NULL_HANDLER,
43827         ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
43828         ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
43829         ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER,
43830         ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER,
43831         ZEND_NULL_HANDLER,
43832         ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
43833         ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER,
43834         ZEND_NULL_HANDLER,
43835         ZEND_NULL_HANDLER,
43836         ZEND_NULL_HANDLER,
43837         ZEND_NULL_HANDLER,
43838         ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER,
43839         ZEND_NULL_HANDLER,
43840         ZEND_NULL_HANDLER,
43841         ZEND_NULL_HANDLER,
43842         ZEND_NULL_HANDLER,
43843         ZEND_NULL_HANDLER,
43844         ZEND_NULL_HANDLER,
43845         ZEND_NULL_HANDLER,
43846         ZEND_NULL_HANDLER,
43847         ZEND_NULL_HANDLER,
43848         ZEND_NULL_HANDLER,
43849         ZEND_NULL_HANDLER,
43850         ZEND_NULL_HANDLER,
43851         ZEND_NULL_HANDLER,
43852         ZEND_NULL_HANDLER,
43853         ZEND_NULL_HANDLER,
43854         ZEND_NULL_HANDLER,
43855         ZEND_NULL_HANDLER,
43856         ZEND_NULL_HANDLER,
43857         ZEND_NULL_HANDLER,
43858         ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER,
43859         ZEND_NULL_HANDLER,
43860         ZEND_NULL_HANDLER,
43861         ZEND_NULL_HANDLER,
43862         ZEND_NULL_HANDLER,
43863         ZEND_NULL_HANDLER,
43864         ZEND_NULL_HANDLER,
43865         ZEND_NULL_HANDLER,
43866         ZEND_NULL_HANDLER,
43867         ZEND_NULL_HANDLER,
43868         ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER,
43869         ZEND_NULL_HANDLER,
43870         ZEND_NULL_HANDLER,
43871         ZEND_NULL_HANDLER,
43872         ZEND_NULL_HANDLER,
43873         ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
43874         ZEND_NULL_HANDLER,
43875         ZEND_NULL_HANDLER,
43876         ZEND_NULL_HANDLER,
43877         ZEND_NULL_HANDLER,
43878         ZEND_NULL_HANDLER,
43879         ZEND_NULL_HANDLER,
43880         ZEND_NULL_HANDLER,
43881         ZEND_NULL_HANDLER,
43882         ZEND_NULL_HANDLER,
43883         ZEND_GOTO_SPEC_CONST_HANDLER,
43884         ZEND_NULL_HANDLER,
43885         ZEND_NULL_HANDLER,
43886         ZEND_NULL_HANDLER,
43887         ZEND_NULL_HANDLER,
43888         ZEND_GOTO_SPEC_CONST_HANDLER,
43889         ZEND_NULL_HANDLER,
43890         ZEND_NULL_HANDLER,
43891         ZEND_NULL_HANDLER,
43892         ZEND_NULL_HANDLER,
43893         ZEND_GOTO_SPEC_CONST_HANDLER,
43894         ZEND_NULL_HANDLER,
43895         ZEND_NULL_HANDLER,
43896         ZEND_NULL_HANDLER,
43897         ZEND_NULL_HANDLER,
43898         ZEND_GOTO_SPEC_CONST_HANDLER,
43899         ZEND_NULL_HANDLER,
43900         ZEND_NULL_HANDLER,
43901         ZEND_NULL_HANDLER,
43902         ZEND_NULL_HANDLER,
43903         ZEND_GOTO_SPEC_CONST_HANDLER,
43904         ZEND_NULL_HANDLER,
43905         ZEND_NULL_HANDLER,
43906         ZEND_NULL_HANDLER,
43907         ZEND_NULL_HANDLER,
43908         ZEND_EXT_STMT_SPEC_HANDLER,
43909         ZEND_EXT_STMT_SPEC_HANDLER,
43910         ZEND_EXT_STMT_SPEC_HANDLER,
43911         ZEND_EXT_STMT_SPEC_HANDLER,
43912         ZEND_EXT_STMT_SPEC_HANDLER,
43913         ZEND_EXT_STMT_SPEC_HANDLER,
43914         ZEND_EXT_STMT_SPEC_HANDLER,
43915         ZEND_EXT_STMT_SPEC_HANDLER,
43916         ZEND_EXT_STMT_SPEC_HANDLER,
43917         ZEND_EXT_STMT_SPEC_HANDLER,
43918         ZEND_EXT_STMT_SPEC_HANDLER,
43919         ZEND_EXT_STMT_SPEC_HANDLER,
43920         ZEND_EXT_STMT_SPEC_HANDLER,
43921         ZEND_EXT_STMT_SPEC_HANDLER,
43922         ZEND_EXT_STMT_SPEC_HANDLER,
43923         ZEND_EXT_STMT_SPEC_HANDLER,
43924         ZEND_EXT_STMT_SPEC_HANDLER,
43925         ZEND_EXT_STMT_SPEC_HANDLER,
43926         ZEND_EXT_STMT_SPEC_HANDLER,
43927         ZEND_EXT_STMT_SPEC_HANDLER,
43928         ZEND_EXT_STMT_SPEC_HANDLER,
43929         ZEND_EXT_STMT_SPEC_HANDLER,
43930         ZEND_EXT_STMT_SPEC_HANDLER,
43931         ZEND_EXT_STMT_SPEC_HANDLER,
43932         ZEND_EXT_STMT_SPEC_HANDLER,
43933         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43934         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43935         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43936         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43937         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43938         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43939         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43940         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43941         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43942         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43943         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43944         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43945         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43946         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43947         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43948         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43949         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43950         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43951         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43952         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43953         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43954         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43955         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43956         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43957         ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
43958         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43959         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43960         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43961         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43962         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43963         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43964         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43965         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43966         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43967         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43968         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43969         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43970         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43971         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43972         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43973         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43974         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43975         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43976         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43977         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43978         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43979         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43980         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43981         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43982         ZEND_EXT_FCALL_END_SPEC_HANDLER,
43983         ZEND_EXT_NOP_SPEC_HANDLER,
43984         ZEND_EXT_NOP_SPEC_HANDLER,
43985         ZEND_EXT_NOP_SPEC_HANDLER,
43986         ZEND_EXT_NOP_SPEC_HANDLER,
43987         ZEND_EXT_NOP_SPEC_HANDLER,
43988         ZEND_EXT_NOP_SPEC_HANDLER,
43989         ZEND_EXT_NOP_SPEC_HANDLER,
43990         ZEND_EXT_NOP_SPEC_HANDLER,
43991         ZEND_EXT_NOP_SPEC_HANDLER,
43992         ZEND_EXT_NOP_SPEC_HANDLER,
43993         ZEND_EXT_NOP_SPEC_HANDLER,
43994         ZEND_EXT_NOP_SPEC_HANDLER,
43995         ZEND_EXT_NOP_SPEC_HANDLER,
43996         ZEND_EXT_NOP_SPEC_HANDLER,
43997         ZEND_EXT_NOP_SPEC_HANDLER,
43998         ZEND_EXT_NOP_SPEC_HANDLER,
43999         ZEND_EXT_NOP_SPEC_HANDLER,
44000         ZEND_EXT_NOP_SPEC_HANDLER,
44001         ZEND_EXT_NOP_SPEC_HANDLER,
44002         ZEND_EXT_NOP_SPEC_HANDLER,
44003         ZEND_EXT_NOP_SPEC_HANDLER,
44004         ZEND_EXT_NOP_SPEC_HANDLER,
44005         ZEND_EXT_NOP_SPEC_HANDLER,
44006         ZEND_EXT_NOP_SPEC_HANDLER,
44007         ZEND_EXT_NOP_SPEC_HANDLER,
44008         ZEND_TICKS_SPEC_HANDLER,
44009         ZEND_TICKS_SPEC_HANDLER,
44010         ZEND_TICKS_SPEC_HANDLER,
44011         ZEND_TICKS_SPEC_HANDLER,
44012         ZEND_TICKS_SPEC_HANDLER,
44013         ZEND_TICKS_SPEC_HANDLER,
44014         ZEND_TICKS_SPEC_HANDLER,
44015         ZEND_TICKS_SPEC_HANDLER,
44016         ZEND_TICKS_SPEC_HANDLER,
44017         ZEND_TICKS_SPEC_HANDLER,
44018         ZEND_TICKS_SPEC_HANDLER,
44019         ZEND_TICKS_SPEC_HANDLER,
44020         ZEND_TICKS_SPEC_HANDLER,
44021         ZEND_TICKS_SPEC_HANDLER,
44022         ZEND_TICKS_SPEC_HANDLER,
44023         ZEND_TICKS_SPEC_HANDLER,
44024         ZEND_TICKS_SPEC_HANDLER,
44025         ZEND_TICKS_SPEC_HANDLER,
44026         ZEND_TICKS_SPEC_HANDLER,
44027         ZEND_TICKS_SPEC_HANDLER,
44028         ZEND_TICKS_SPEC_HANDLER,
44029         ZEND_TICKS_SPEC_HANDLER,
44030         ZEND_TICKS_SPEC_HANDLER,
44031         ZEND_TICKS_SPEC_HANDLER,
44032         ZEND_TICKS_SPEC_HANDLER,
44033         ZEND_NULL_HANDLER,
44034         ZEND_NULL_HANDLER,
44035         ZEND_NULL_HANDLER,
44036         ZEND_NULL_HANDLER,
44037         ZEND_NULL_HANDLER,
44038         ZEND_NULL_HANDLER,
44039         ZEND_NULL_HANDLER,
44040         ZEND_NULL_HANDLER,
44041         ZEND_NULL_HANDLER,
44042         ZEND_NULL_HANDLER,
44043         ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44044         ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44045         ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44046         ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44047         ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER,
44048         ZEND_NULL_HANDLER,
44049         ZEND_NULL_HANDLER,
44050         ZEND_NULL_HANDLER,
44051         ZEND_NULL_HANDLER,
44052         ZEND_NULL_HANDLER,
44053         ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44054         ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44055         ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44056         ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44057         ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER,
44058         ZEND_NULL_HANDLER,
44059         ZEND_NULL_HANDLER,
44060         ZEND_NULL_HANDLER,
44061         ZEND_NULL_HANDLER,
44062         ZEND_CATCH_SPEC_CONST_CV_HANDLER,
44063         ZEND_NULL_HANDLER,
44064         ZEND_NULL_HANDLER,
44065         ZEND_NULL_HANDLER,
44066         ZEND_NULL_HANDLER,
44067         ZEND_NULL_HANDLER,
44068         ZEND_NULL_HANDLER,
44069         ZEND_NULL_HANDLER,
44070         ZEND_NULL_HANDLER,
44071         ZEND_NULL_HANDLER,
44072         ZEND_NULL_HANDLER,
44073         ZEND_NULL_HANDLER,
44074         ZEND_NULL_HANDLER,
44075         ZEND_NULL_HANDLER,
44076         ZEND_NULL_HANDLER,
44077         ZEND_NULL_HANDLER,
44078         ZEND_NULL_HANDLER,
44079         ZEND_NULL_HANDLER,
44080         ZEND_NULL_HANDLER,
44081         ZEND_NULL_HANDLER,
44082         ZEND_NULL_HANDLER,
44083         ZEND_THROW_SPEC_CONST_HANDLER,
44084         ZEND_THROW_SPEC_CONST_HANDLER,
44085         ZEND_THROW_SPEC_CONST_HANDLER,
44086         ZEND_THROW_SPEC_CONST_HANDLER,
44087         ZEND_THROW_SPEC_CONST_HANDLER,
44088         ZEND_THROW_SPEC_TMP_HANDLER,
44089         ZEND_THROW_SPEC_TMP_HANDLER,
44090         ZEND_THROW_SPEC_TMP_HANDLER,
44091         ZEND_THROW_SPEC_TMP_HANDLER,
44092         ZEND_THROW_SPEC_TMP_HANDLER,
44093         ZEND_THROW_SPEC_VAR_HANDLER,
44094         ZEND_THROW_SPEC_VAR_HANDLER,
44095         ZEND_THROW_SPEC_VAR_HANDLER,
44096         ZEND_THROW_SPEC_VAR_HANDLER,
44097         ZEND_THROW_SPEC_VAR_HANDLER,
44098         ZEND_NULL_HANDLER,
44099         ZEND_NULL_HANDLER,
44100         ZEND_NULL_HANDLER,
44101         ZEND_NULL_HANDLER,
44102         ZEND_NULL_HANDLER,
44103         ZEND_THROW_SPEC_CV_HANDLER,
44104         ZEND_THROW_SPEC_CV_HANDLER,
44105         ZEND_THROW_SPEC_CV_HANDLER,
44106         ZEND_THROW_SPEC_CV_HANDLER,
44107         ZEND_THROW_SPEC_CV_HANDLER,
44108         ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44109         ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44110         ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44111         ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44112         ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44113         ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44114         ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44115         ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44116         ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44117         ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44118         ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44119         ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44120         ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44121         ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44122         ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44123         ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44124         ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44125         ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44126         ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44127         ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44128         ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
44129         ZEND_FETCH_CLASS_SPEC_TMP_HANDLER,
44130         ZEND_FETCH_CLASS_SPEC_VAR_HANDLER,
44131         ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
44132         ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
44133         ZEND_CLONE_SPEC_CONST_HANDLER,
44134         ZEND_CLONE_SPEC_CONST_HANDLER,
44135         ZEND_CLONE_SPEC_CONST_HANDLER,
44136         ZEND_CLONE_SPEC_CONST_HANDLER,
44137         ZEND_CLONE_SPEC_CONST_HANDLER,
44138         ZEND_CLONE_SPEC_TMP_HANDLER,
44139         ZEND_CLONE_SPEC_TMP_HANDLER,
44140         ZEND_CLONE_SPEC_TMP_HANDLER,
44141         ZEND_CLONE_SPEC_TMP_HANDLER,
44142         ZEND_CLONE_SPEC_TMP_HANDLER,
44143         ZEND_CLONE_SPEC_VAR_HANDLER,
44144         ZEND_CLONE_SPEC_VAR_HANDLER,
44145         ZEND_CLONE_SPEC_VAR_HANDLER,
44146         ZEND_CLONE_SPEC_VAR_HANDLER,
44147         ZEND_CLONE_SPEC_VAR_HANDLER,
44148         ZEND_CLONE_SPEC_UNUSED_HANDLER,
44149         ZEND_CLONE_SPEC_UNUSED_HANDLER,
44150         ZEND_CLONE_SPEC_UNUSED_HANDLER,
44151         ZEND_CLONE_SPEC_UNUSED_HANDLER,
44152         ZEND_CLONE_SPEC_UNUSED_HANDLER,
44153         ZEND_CLONE_SPEC_CV_HANDLER,
44154         ZEND_CLONE_SPEC_CV_HANDLER,
44155         ZEND_CLONE_SPEC_CV_HANDLER,
44156         ZEND_CLONE_SPEC_CV_HANDLER,
44157         ZEND_CLONE_SPEC_CV_HANDLER,
44158         ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44159         ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44160         ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44161         ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44162         ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
44163         ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44164         ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44165         ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44166         ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44167         ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
44168         ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44169         ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44170         ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44171         ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44172         ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
44173         ZEND_NULL_HANDLER,
44174         ZEND_NULL_HANDLER,
44175         ZEND_NULL_HANDLER,
44176         ZEND_NULL_HANDLER,
44177         ZEND_NULL_HANDLER,
44178         ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44179         ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44180         ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44181         ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44182         ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
44183         ZEND_NULL_HANDLER,
44184         ZEND_NULL_HANDLER,
44185         ZEND_NULL_HANDLER,
44186         ZEND_NULL_HANDLER,
44187         ZEND_NULL_HANDLER,
44188         ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER,
44189         ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER,
44190         ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER,
44191         ZEND_NULL_HANDLER,
44192         ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER,
44193         ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
44194         ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER,
44195         ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER,
44196         ZEND_NULL_HANDLER,
44197         ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER,
44198         ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
44199         ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER,
44200         ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER,
44201         ZEND_NULL_HANDLER,
44202         ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
44203         ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
44204         ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER,
44205         ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER,
44206         ZEND_NULL_HANDLER,
44207         ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
44208         ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
44209         ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER,
44210         ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER,
44211         ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
44212         ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
44213         ZEND_NULL_HANDLER,
44214         ZEND_NULL_HANDLER,
44215         ZEND_NULL_HANDLER,
44216         ZEND_NULL_HANDLER,
44217         ZEND_NULL_HANDLER,
44218         ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
44219         ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER,
44220         ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER,
44221         ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
44222         ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
44223         ZEND_NULL_HANDLER,
44224         ZEND_NULL_HANDLER,
44225         ZEND_NULL_HANDLER,
44226         ZEND_NULL_HANDLER,
44227         ZEND_NULL_HANDLER,
44228         ZEND_NULL_HANDLER,
44229         ZEND_NULL_HANDLER,
44230         ZEND_NULL_HANDLER,
44231         ZEND_NULL_HANDLER,
44232         ZEND_NULL_HANDLER,
44233         ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER,
44234         ZEND_NULL_HANDLER,
44235         ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER,
44236         ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
44237         ZEND_NULL_HANDLER,
44238         ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER,
44239         ZEND_NULL_HANDLER,
44240         ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER,
44241         ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER,
44242         ZEND_NULL_HANDLER,
44243         ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER,
44244         ZEND_NULL_HANDLER,
44245         ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER,
44246         ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER,
44247         ZEND_NULL_HANDLER,
44248         ZEND_NULL_HANDLER,
44249         ZEND_NULL_HANDLER,
44250         ZEND_NULL_HANDLER,
44251         ZEND_NULL_HANDLER,
44252         ZEND_NULL_HANDLER,
44253         ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER,
44254         ZEND_NULL_HANDLER,
44255         ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER,
44256         ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
44257         ZEND_NULL_HANDLER,
44258         ZEND_NULL_HANDLER,
44259         ZEND_NULL_HANDLER,
44260         ZEND_NULL_HANDLER,
44261         ZEND_NULL_HANDLER,
44262         ZEND_NULL_HANDLER,
44263         ZEND_NULL_HANDLER,
44264         ZEND_NULL_HANDLER,
44265         ZEND_NULL_HANDLER,
44266         ZEND_NULL_HANDLER,
44267         ZEND_NULL_HANDLER,
44268         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER,
44269         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER,
44270         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER,
44271         ZEND_NULL_HANDLER,
44272         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER,
44273         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER,
44274         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER,
44275         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER,
44276         ZEND_NULL_HANDLER,
44277         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER,
44278         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
44279         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER,
44280         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER,
44281         ZEND_NULL_HANDLER,
44282         ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
44283         ZEND_NULL_HANDLER,
44284         ZEND_NULL_HANDLER,
44285         ZEND_NULL_HANDLER,
44286         ZEND_NULL_HANDLER,
44287         ZEND_NULL_HANDLER,
44288         ZEND_NULL_HANDLER,
44289         ZEND_NULL_HANDLER,
44290         ZEND_NULL_HANDLER,
44291         ZEND_NULL_HANDLER,
44292         ZEND_NULL_HANDLER,
44293         ZEND_NULL_HANDLER,
44294         ZEND_NULL_HANDLER,
44295         ZEND_NULL_HANDLER,
44296         ZEND_NULL_HANDLER,
44297         ZEND_NULL_HANDLER,
44298         ZEND_NULL_HANDLER,
44299         ZEND_NULL_HANDLER,
44300         ZEND_NULL_HANDLER,
44301         ZEND_NULL_HANDLER,
44302         ZEND_NULL_HANDLER,
44303         ZEND_NULL_HANDLER,
44304         ZEND_NULL_HANDLER,
44305         ZEND_NULL_HANDLER,
44306         ZEND_NULL_HANDLER,
44307         ZEND_NULL_HANDLER,
44308         ZEND_NULL_HANDLER,
44309         ZEND_NULL_HANDLER,
44310         ZEND_NULL_HANDLER,
44311         ZEND_NULL_HANDLER,
44312         ZEND_NULL_HANDLER,
44313         ZEND_NULL_HANDLER,
44314         ZEND_NULL_HANDLER,
44315         ZEND_NULL_HANDLER,
44316         ZEND_NULL_HANDLER,
44317         ZEND_NULL_HANDLER,
44318         ZEND_NULL_HANDLER,
44319         ZEND_NULL_HANDLER,
44320         ZEND_NULL_HANDLER,
44321         ZEND_NULL_HANDLER,
44322         ZEND_NULL_HANDLER,
44323         ZEND_NULL_HANDLER,
44324         ZEND_NULL_HANDLER,
44325         ZEND_NULL_HANDLER,
44326         ZEND_NULL_HANDLER,
44327         ZEND_NULL_HANDLER,
44328         ZEND_NULL_HANDLER,
44329         ZEND_NULL_HANDLER,
44330         ZEND_NULL_HANDLER,
44331         ZEND_NULL_HANDLER,
44332         ZEND_NULL_HANDLER,
44333         ZEND_NULL_HANDLER,
44334         ZEND_NULL_HANDLER,
44335         ZEND_NULL_HANDLER,
44336         ZEND_NULL_HANDLER,
44337         ZEND_NULL_HANDLER,
44338         ZEND_NULL_HANDLER,
44339         ZEND_NULL_HANDLER,
44340         ZEND_NULL_HANDLER,
44341         ZEND_NULL_HANDLER,
44342         ZEND_NULL_HANDLER,
44343         ZEND_NULL_HANDLER,
44344         ZEND_NULL_HANDLER,
44345         ZEND_NULL_HANDLER,
44346         ZEND_NULL_HANDLER,
44347         ZEND_NULL_HANDLER,
44348         ZEND_NULL_HANDLER,
44349         ZEND_NULL_HANDLER,
44350         ZEND_NULL_HANDLER,
44351         ZEND_NULL_HANDLER,
44352         ZEND_NULL_HANDLER,
44353         ZEND_NULL_HANDLER,
44354         ZEND_NULL_HANDLER,
44355         ZEND_NULL_HANDLER,
44356         ZEND_NULL_HANDLER,
44357         ZEND_NULL_HANDLER,
44358         ZEND_NULL_HANDLER,
44359         ZEND_NULL_HANDLER,
44360         ZEND_NULL_HANDLER,
44361         ZEND_NULL_HANDLER,
44362         ZEND_NULL_HANDLER,
44363         ZEND_NULL_HANDLER,
44364         ZEND_NULL_HANDLER,
44365         ZEND_NULL_HANDLER,
44366         ZEND_NULL_HANDLER,
44367         ZEND_NULL_HANDLER,
44368         ZEND_NULL_HANDLER,
44369         ZEND_NULL_HANDLER,
44370         ZEND_NULL_HANDLER,
44371         ZEND_NULL_HANDLER,
44372         ZEND_NULL_HANDLER,
44373         ZEND_NULL_HANDLER,
44374         ZEND_NULL_HANDLER,
44375         ZEND_NULL_HANDLER,
44376         ZEND_NULL_HANDLER,
44377         ZEND_NULL_HANDLER,
44378         ZEND_NULL_HANDLER,
44379         ZEND_NULL_HANDLER,
44380         ZEND_NULL_HANDLER,
44381         ZEND_NULL_HANDLER,
44382         ZEND_NULL_HANDLER,
44383         ZEND_NULL_HANDLER,
44384         ZEND_NULL_HANDLER,
44385         ZEND_NULL_HANDLER,
44386         ZEND_NULL_HANDLER,
44387         ZEND_NULL_HANDLER,
44388         ZEND_NULL_HANDLER,
44389         ZEND_NULL_HANDLER,
44390         ZEND_NULL_HANDLER,
44391         ZEND_NULL_HANDLER,
44392         ZEND_NULL_HANDLER,
44393         ZEND_NULL_HANDLER,
44394         ZEND_NULL_HANDLER,
44395         ZEND_NULL_HANDLER,
44396         ZEND_NULL_HANDLER,
44397         ZEND_NULL_HANDLER,
44398         ZEND_NULL_HANDLER,
44399         ZEND_NULL_HANDLER,
44400         ZEND_NULL_HANDLER,
44401         ZEND_NULL_HANDLER,
44402         ZEND_NULL_HANDLER,
44403         ZEND_NULL_HANDLER,
44404         ZEND_NULL_HANDLER,
44405         ZEND_NULL_HANDLER,
44406         ZEND_NULL_HANDLER,
44407         ZEND_NULL_HANDLER,
44408         ZEND_NULL_HANDLER,
44409         ZEND_NULL_HANDLER,
44410         ZEND_NULL_HANDLER,
44411         ZEND_NULL_HANDLER,
44412         ZEND_NULL_HANDLER,
44413         ZEND_NULL_HANDLER,
44414         ZEND_NULL_HANDLER,
44415         ZEND_NULL_HANDLER,
44416         ZEND_NULL_HANDLER,
44417         ZEND_NULL_HANDLER,
44418         ZEND_NULL_HANDLER,
44419         ZEND_NULL_HANDLER,
44420         ZEND_NULL_HANDLER,
44421         ZEND_NULL_HANDLER,
44422         ZEND_NULL_HANDLER,
44423         ZEND_NULL_HANDLER,
44424         ZEND_NULL_HANDLER,
44425         ZEND_NULL_HANDLER,
44426         ZEND_NULL_HANDLER,
44427         ZEND_NULL_HANDLER,
44428         ZEND_NULL_HANDLER,
44429         ZEND_NULL_HANDLER,
44430         ZEND_NULL_HANDLER,
44431         ZEND_NULL_HANDLER,
44432         ZEND_NULL_HANDLER,
44433         ZEND_NULL_HANDLER,
44434         ZEND_NULL_HANDLER,
44435         ZEND_NULL_HANDLER,
44436         ZEND_NULL_HANDLER,
44437         ZEND_NULL_HANDLER,
44438         ZEND_NULL_HANDLER,
44439         ZEND_NULL_HANDLER,
44440         ZEND_NULL_HANDLER,
44441         ZEND_NULL_HANDLER,
44442         ZEND_NULL_HANDLER,
44443         ZEND_NULL_HANDLER,
44444         ZEND_NULL_HANDLER,
44445         ZEND_NULL_HANDLER,
44446         ZEND_NULL_HANDLER,
44447         ZEND_NULL_HANDLER,
44448         ZEND_NULL_HANDLER,
44449         ZEND_NULL_HANDLER,
44450         ZEND_NULL_HANDLER,
44451         ZEND_NULL_HANDLER,
44452         ZEND_NULL_HANDLER,
44453         ZEND_NULL_HANDLER,
44454         ZEND_NULL_HANDLER,
44455         ZEND_NULL_HANDLER,
44456         ZEND_NULL_HANDLER,
44457         ZEND_NULL_HANDLER,
44458         ZEND_NULL_HANDLER,
44459         ZEND_NULL_HANDLER,
44460         ZEND_NULL_HANDLER,
44461         ZEND_NULL_HANDLER,
44462         ZEND_NULL_HANDLER,
44463         ZEND_NULL_HANDLER,
44464         ZEND_NULL_HANDLER,
44465         ZEND_NULL_HANDLER,
44466         ZEND_NULL_HANDLER,
44467         ZEND_NULL_HANDLER,
44468         ZEND_NULL_HANDLER,
44469         ZEND_NULL_HANDLER,
44470         ZEND_NULL_HANDLER,
44471         ZEND_NULL_HANDLER,
44472         ZEND_NULL_HANDLER,
44473         ZEND_NULL_HANDLER,
44474         ZEND_NULL_HANDLER,
44475         ZEND_NULL_HANDLER,
44476         ZEND_NULL_HANDLER,
44477         ZEND_NULL_HANDLER,
44478         ZEND_NULL_HANDLER,
44479         ZEND_NULL_HANDLER,
44480         ZEND_NULL_HANDLER,
44481         ZEND_NULL_HANDLER,
44482         ZEND_NULL_HANDLER,
44483         ZEND_NULL_HANDLER,
44484         ZEND_NULL_HANDLER,
44485         ZEND_NULL_HANDLER,
44486         ZEND_NULL_HANDLER,
44487         ZEND_NULL_HANDLER,
44488         ZEND_NULL_HANDLER,
44489         ZEND_NULL_HANDLER,
44490         ZEND_NULL_HANDLER,
44491         ZEND_NULL_HANDLER,
44492         ZEND_NULL_HANDLER,
44493         ZEND_NULL_HANDLER,
44494         ZEND_NULL_HANDLER,
44495         ZEND_NULL_HANDLER,
44496         ZEND_NULL_HANDLER,
44497         ZEND_NULL_HANDLER,
44498         ZEND_NULL_HANDLER,
44499         ZEND_NULL_HANDLER,
44500         ZEND_NULL_HANDLER,
44501         ZEND_NULL_HANDLER,
44502         ZEND_NULL_HANDLER,
44503         ZEND_NULL_HANDLER,
44504         ZEND_NULL_HANDLER,
44505         ZEND_NULL_HANDLER,
44506         ZEND_NULL_HANDLER,
44507         ZEND_NULL_HANDLER,
44508         ZEND_NULL_HANDLER,
44509         ZEND_NULL_HANDLER,
44510         ZEND_NULL_HANDLER,
44511         ZEND_NULL_HANDLER,
44512         ZEND_NULL_HANDLER,
44513         ZEND_NULL_HANDLER,
44514         ZEND_NULL_HANDLER,
44515         ZEND_NULL_HANDLER,
44516         ZEND_NULL_HANDLER,
44517         ZEND_NULL_HANDLER,
44518         ZEND_NULL_HANDLER,
44519         ZEND_NULL_HANDLER,
44520         ZEND_NULL_HANDLER,
44521         ZEND_NULL_HANDLER,
44522         ZEND_NULL_HANDLER,
44523         ZEND_NULL_HANDLER,
44524         ZEND_NULL_HANDLER,
44525         ZEND_NULL_HANDLER,
44526         ZEND_NULL_HANDLER,
44527         ZEND_NULL_HANDLER,
44528         ZEND_NULL_HANDLER,
44529         ZEND_NULL_HANDLER,
44530         ZEND_NULL_HANDLER,
44531         ZEND_NULL_HANDLER,
44532         ZEND_NULL_HANDLER,
44533         ZEND_NULL_HANDLER,
44534         ZEND_NULL_HANDLER,
44535         ZEND_NULL_HANDLER,
44536         ZEND_NULL_HANDLER,
44537         ZEND_NULL_HANDLER,
44538         ZEND_NULL_HANDLER,
44539         ZEND_NULL_HANDLER,
44540         ZEND_NULL_HANDLER,
44541         ZEND_NULL_HANDLER,
44542         ZEND_NULL_HANDLER,
44543         ZEND_NULL_HANDLER,
44544         ZEND_NULL_HANDLER,
44545         ZEND_NULL_HANDLER,
44546         ZEND_NULL_HANDLER,
44547         ZEND_NULL_HANDLER,
44548         ZEND_NULL_HANDLER,
44549         ZEND_NULL_HANDLER,
44550         ZEND_NULL_HANDLER,
44551         ZEND_NULL_HANDLER,
44552         ZEND_NULL_HANDLER,
44553         ZEND_NULL_HANDLER,
44554         ZEND_NULL_HANDLER,
44555         ZEND_NULL_HANDLER,
44556         ZEND_NULL_HANDLER,
44557         ZEND_NULL_HANDLER,
44558         ZEND_NULL_HANDLER,
44559         ZEND_NULL_HANDLER,
44560         ZEND_NULL_HANDLER,
44561         ZEND_NULL_HANDLER,
44562         ZEND_NULL_HANDLER,
44563         ZEND_NULL_HANDLER,
44564         ZEND_NULL_HANDLER,
44565         ZEND_NULL_HANDLER,
44566         ZEND_NULL_HANDLER,
44567         ZEND_NULL_HANDLER,
44568         ZEND_NULL_HANDLER,
44569         ZEND_NULL_HANDLER,
44570         ZEND_NULL_HANDLER,
44571         ZEND_NULL_HANDLER,
44572         ZEND_NULL_HANDLER,
44573         ZEND_NULL_HANDLER,
44574         ZEND_NULL_HANDLER,
44575         ZEND_NULL_HANDLER,
44576         ZEND_NULL_HANDLER,
44577         ZEND_NULL_HANDLER,
44578         ZEND_NULL_HANDLER,
44579         ZEND_NULL_HANDLER,
44580         ZEND_NULL_HANDLER,
44581         ZEND_NULL_HANDLER,
44582         ZEND_NULL_HANDLER,
44583         ZEND_NULL_HANDLER,
44584         ZEND_NULL_HANDLER,
44585         ZEND_NULL_HANDLER,
44586         ZEND_NULL_HANDLER,
44587         ZEND_NULL_HANDLER,
44588         ZEND_NULL_HANDLER,
44589         ZEND_NULL_HANDLER,
44590         ZEND_NULL_HANDLER,
44591         ZEND_NULL_HANDLER,
44592         ZEND_NULL_HANDLER,
44593         ZEND_NULL_HANDLER,
44594         ZEND_NULL_HANDLER,
44595         ZEND_NULL_HANDLER,
44596         ZEND_NULL_HANDLER,
44597         ZEND_NULL_HANDLER,
44598         ZEND_NULL_HANDLER,
44599         ZEND_NULL_HANDLER,
44600         ZEND_NULL_HANDLER,
44601         ZEND_NULL_HANDLER,
44602         ZEND_NULL_HANDLER,
44603         ZEND_NULL_HANDLER,
44604         ZEND_NULL_HANDLER,
44605         ZEND_NULL_HANDLER,
44606         ZEND_NULL_HANDLER,
44607         ZEND_NULL_HANDLER,
44608         ZEND_NULL_HANDLER,
44609         ZEND_NULL_HANDLER,
44610         ZEND_NULL_HANDLER,
44611         ZEND_NULL_HANDLER,
44612         ZEND_NULL_HANDLER,
44613         ZEND_NULL_HANDLER,
44614         ZEND_NULL_HANDLER,
44615         ZEND_NULL_HANDLER,
44616         ZEND_NULL_HANDLER,
44617         ZEND_NULL_HANDLER,
44618         ZEND_NULL_HANDLER,
44619         ZEND_NULL_HANDLER,
44620         ZEND_NULL_HANDLER,
44621         ZEND_NULL_HANDLER,
44622         ZEND_NULL_HANDLER,
44623         ZEND_NULL_HANDLER,
44624         ZEND_NULL_HANDLER,
44625         ZEND_NULL_HANDLER,
44626         ZEND_NULL_HANDLER,
44627         ZEND_NULL_HANDLER,
44628         ZEND_NULL_HANDLER,
44629         ZEND_NULL_HANDLER,
44630         ZEND_NULL_HANDLER,
44631         ZEND_NULL_HANDLER,
44632         ZEND_NULL_HANDLER,
44633         ZEND_NULL_HANDLER,
44634         ZEND_NULL_HANDLER,
44635         ZEND_NULL_HANDLER,
44636         ZEND_NULL_HANDLER,
44637         ZEND_NULL_HANDLER,
44638         ZEND_NULL_HANDLER,
44639         ZEND_NULL_HANDLER,
44640         ZEND_NULL_HANDLER,
44641         ZEND_NULL_HANDLER,
44642         ZEND_NULL_HANDLER,
44643         ZEND_NULL_HANDLER,
44644         ZEND_NULL_HANDLER,
44645         ZEND_NULL_HANDLER,
44646         ZEND_NULL_HANDLER,
44647         ZEND_NULL_HANDLER,
44648         ZEND_NULL_HANDLER,
44649         ZEND_NULL_HANDLER,
44650         ZEND_NULL_HANDLER,
44651         ZEND_NULL_HANDLER,
44652         ZEND_NULL_HANDLER,
44653         ZEND_NULL_HANDLER,
44654         ZEND_NULL_HANDLER,
44655         ZEND_NULL_HANDLER,
44656         ZEND_NULL_HANDLER,
44657         ZEND_NULL_HANDLER,
44658         ZEND_NULL_HANDLER,
44659         ZEND_NULL_HANDLER,
44660         ZEND_NULL_HANDLER,
44661         ZEND_NULL_HANDLER,
44662         ZEND_NULL_HANDLER,
44663         ZEND_NULL_HANDLER,
44664         ZEND_NULL_HANDLER,
44665         ZEND_NULL_HANDLER,
44666         ZEND_NULL_HANDLER,
44667         ZEND_NULL_HANDLER,
44668         ZEND_NULL_HANDLER,
44669         ZEND_NULL_HANDLER,
44670         ZEND_NULL_HANDLER,
44671         ZEND_NULL_HANDLER,
44672         ZEND_NULL_HANDLER,
44673         ZEND_NULL_HANDLER,
44674         ZEND_NULL_HANDLER,
44675         ZEND_NULL_HANDLER,
44676         ZEND_NULL_HANDLER,
44677         ZEND_NULL_HANDLER,
44678         ZEND_NULL_HANDLER,
44679         ZEND_NULL_HANDLER,
44680         ZEND_NULL_HANDLER,
44681         ZEND_NULL_HANDLER,
44682         ZEND_NULL_HANDLER,
44683         ZEND_NULL_HANDLER,
44684         ZEND_NULL_HANDLER,
44685         ZEND_NULL_HANDLER,
44686         ZEND_NULL_HANDLER,
44687         ZEND_NULL_HANDLER,
44688         ZEND_NULL_HANDLER,
44689         ZEND_NULL_HANDLER,
44690         ZEND_NULL_HANDLER,
44691         ZEND_NULL_HANDLER,
44692         ZEND_NULL_HANDLER,
44693         ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
44694         ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER,
44695         ZEND_PRE_INC_OBJ_SPEC_VAR_VAR_HANDLER,
44696         ZEND_NULL_HANDLER,
44697         ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
44698         ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
44699         ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER,
44700         ZEND_PRE_INC_OBJ_SPEC_UNUSED_VAR_HANDLER,
44701         ZEND_NULL_HANDLER,
44702         ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
44703         ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
44704         ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER,
44705         ZEND_PRE_INC_OBJ_SPEC_CV_VAR_HANDLER,
44706         ZEND_NULL_HANDLER,
44707         ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
44708         ZEND_NULL_HANDLER,
44709         ZEND_NULL_HANDLER,
44710         ZEND_NULL_HANDLER,
44711         ZEND_NULL_HANDLER,
44712         ZEND_NULL_HANDLER,
44713         ZEND_NULL_HANDLER,
44714         ZEND_NULL_HANDLER,
44715         ZEND_NULL_HANDLER,
44716         ZEND_NULL_HANDLER,
44717         ZEND_NULL_HANDLER,
44718         ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER,
44719         ZEND_PRE_DEC_OBJ_SPEC_VAR_TMP_HANDLER,
44720         ZEND_PRE_DEC_OBJ_SPEC_VAR_VAR_HANDLER,
44721         ZEND_NULL_HANDLER,
44722         ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER,
44723         ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER,
44724         ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER,
44725         ZEND_PRE_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER,
44726         ZEND_NULL_HANDLER,
44727         ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER,
44728         ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER,
44729         ZEND_PRE_DEC_OBJ_SPEC_CV_TMP_HANDLER,
44730         ZEND_PRE_DEC_OBJ_SPEC_CV_VAR_HANDLER,
44731         ZEND_NULL_HANDLER,
44732         ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER,
44733         ZEND_NULL_HANDLER,
44734         ZEND_NULL_HANDLER,
44735         ZEND_NULL_HANDLER,
44736         ZEND_NULL_HANDLER,
44737         ZEND_NULL_HANDLER,
44738         ZEND_NULL_HANDLER,
44739         ZEND_NULL_HANDLER,
44740         ZEND_NULL_HANDLER,
44741         ZEND_NULL_HANDLER,
44742         ZEND_NULL_HANDLER,
44743         ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
44744         ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER,
44745         ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER,
44746         ZEND_NULL_HANDLER,
44747         ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
44748         ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
44749         ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER,
44750         ZEND_POST_INC_OBJ_SPEC_UNUSED_VAR_HANDLER,
44751         ZEND_NULL_HANDLER,
44752         ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
44753         ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
44754         ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER,
44755         ZEND_POST_INC_OBJ_SPEC_CV_VAR_HANDLER,
44756         ZEND_NULL_HANDLER,
44757         ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
44758         ZEND_NULL_HANDLER,
44759         ZEND_NULL_HANDLER,
44760         ZEND_NULL_HANDLER,
44761         ZEND_NULL_HANDLER,
44762         ZEND_NULL_HANDLER,
44763         ZEND_NULL_HANDLER,
44764         ZEND_NULL_HANDLER,
44765         ZEND_NULL_HANDLER,
44766         ZEND_NULL_HANDLER,
44767         ZEND_NULL_HANDLER,
44768         ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER,
44769         ZEND_POST_DEC_OBJ_SPEC_VAR_TMP_HANDLER,
44770         ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER,
44771         ZEND_NULL_HANDLER,
44772         ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER,
44773         ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER,
44774         ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER,
44775         ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER,
44776         ZEND_NULL_HANDLER,
44777         ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER,
44778         ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER,
44779         ZEND_POST_DEC_OBJ_SPEC_CV_TMP_HANDLER,
44780         ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER,
44781         ZEND_NULL_HANDLER,
44782         ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER,
44783         ZEND_NULL_HANDLER,
44784         ZEND_NULL_HANDLER,
44785         ZEND_NULL_HANDLER,
44786         ZEND_NULL_HANDLER,
44787         ZEND_NULL_HANDLER,
44788         ZEND_NULL_HANDLER,
44789         ZEND_NULL_HANDLER,
44790         ZEND_NULL_HANDLER,
44791         ZEND_NULL_HANDLER,
44792         ZEND_NULL_HANDLER,
44793         ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER,
44794         ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER,
44795         ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER,
44796         ZEND_NULL_HANDLER,
44797         ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER,
44798         ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER,
44799         ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER,
44800         ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER,
44801         ZEND_NULL_HANDLER,
44802         ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER,
44803         ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER,
44804         ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER,
44805         ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER,
44806         ZEND_NULL_HANDLER,
44807         ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER,
44808         ZEND_NULL_HANDLER,
44809         ZEND_NULL_HANDLER,
44810         ZEND_NULL_HANDLER,
44811         ZEND_NULL_HANDLER,
44812         ZEND_NULL_HANDLER,
44813         ZEND_NULL_HANDLER,
44814         ZEND_NULL_HANDLER,
44815         ZEND_NULL_HANDLER,
44816         ZEND_NULL_HANDLER,
44817         ZEND_NULL_HANDLER,
44818         ZEND_NULL_HANDLER,
44819         ZEND_NULL_HANDLER,
44820         ZEND_NULL_HANDLER,
44821         ZEND_NULL_HANDLER,
44822         ZEND_NULL_HANDLER,
44823         ZEND_NULL_HANDLER,
44824         ZEND_NULL_HANDLER,
44825         ZEND_NULL_HANDLER,
44826         ZEND_NULL_HANDLER,
44827         ZEND_NULL_HANDLER,
44828         ZEND_NULL_HANDLER,
44829         ZEND_NULL_HANDLER,
44830         ZEND_NULL_HANDLER,
44831         ZEND_NULL_HANDLER,
44832         ZEND_NULL_HANDLER,
44833         ZEND_NULL_HANDLER,
44834         ZEND_NULL_HANDLER,
44835         ZEND_NULL_HANDLER,
44836         ZEND_NULL_HANDLER,
44837         ZEND_NULL_HANDLER,
44838         ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
44839         ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
44840         ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
44841         ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
44842         ZEND_INSTANCEOF_SPEC_TMP_HANDLER,
44843         ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
44844         ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
44845         ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
44846         ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
44847         ZEND_INSTANCEOF_SPEC_VAR_HANDLER,
44848         ZEND_NULL_HANDLER,
44849         ZEND_NULL_HANDLER,
44850         ZEND_NULL_HANDLER,
44851         ZEND_NULL_HANDLER,
44852         ZEND_NULL_HANDLER,
44853         ZEND_INSTANCEOF_SPEC_CV_HANDLER,
44854         ZEND_INSTANCEOF_SPEC_CV_HANDLER,
44855         ZEND_INSTANCEOF_SPEC_CV_HANDLER,
44856         ZEND_INSTANCEOF_SPEC_CV_HANDLER,
44857         ZEND_INSTANCEOF_SPEC_CV_HANDLER,
44858         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44859         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44860         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44861         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44862         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44863         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44864         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44865         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44866         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44867         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44868         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44869         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44870         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44871         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44872         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44873         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44874         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44875         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44876         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44877         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44878         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44879         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44880         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44881         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44882         ZEND_DECLARE_CLASS_SPEC_HANDLER,
44883         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44884         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44885         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44886         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44887         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44888         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44889         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44890         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44891         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44892         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44893         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44894         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44895         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44896         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44897         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44898         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44899         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44900         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44901         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44902         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44903         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44904         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44905         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44906         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44907         ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
44908         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44909         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44910         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44911         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44912         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44913         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44914         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44915         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44916         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44917         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44918         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44919         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44920         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44921         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44922         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44923         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44924         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44925         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44926         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44927         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44928         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44929         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44930         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44931         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44932         ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
44933         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44934         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44935         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44936         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44937         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44938         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44939         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44940         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44941         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44942         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44943         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44944         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44945         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44946         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44947         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44948         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44949         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44950         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44951         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44952         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44953         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44954         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44955         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44956         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44957         ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER,
44958         ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
44959         ZEND_NULL_HANDLER,
44960         ZEND_NULL_HANDLER,
44961         ZEND_NULL_HANDLER,
44962         ZEND_NULL_HANDLER,
44963         ZEND_NULL_HANDLER,
44964         ZEND_NULL_HANDLER,
44965         ZEND_NULL_HANDLER,
44966         ZEND_NULL_HANDLER,
44967         ZEND_NULL_HANDLER,
44968         ZEND_NULL_HANDLER,
44969         ZEND_NULL_HANDLER,
44970         ZEND_NULL_HANDLER,
44971         ZEND_NULL_HANDLER,
44972         ZEND_NULL_HANDLER,
44973         ZEND_NULL_HANDLER,
44974         ZEND_NULL_HANDLER,
44975         ZEND_NULL_HANDLER,
44976         ZEND_NULL_HANDLER,
44977         ZEND_NULL_HANDLER,
44978         ZEND_NULL_HANDLER,
44979         ZEND_NULL_HANDLER,
44980         ZEND_NULL_HANDLER,
44981         ZEND_NULL_HANDLER,
44982         ZEND_NULL_HANDLER,
44983         ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
44984         ZEND_NULL_HANDLER,
44985         ZEND_NULL_HANDLER,
44986         ZEND_NULL_HANDLER,
44987         ZEND_NULL_HANDLER,
44988         ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
44989         ZEND_NULL_HANDLER,
44990         ZEND_NULL_HANDLER,
44991         ZEND_NULL_HANDLER,
44992         ZEND_NULL_HANDLER,
44993         ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
44994         ZEND_NULL_HANDLER,
44995         ZEND_NULL_HANDLER,
44996         ZEND_NULL_HANDLER,
44997         ZEND_NULL_HANDLER,
44998         ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
44999         ZEND_NULL_HANDLER,
45000         ZEND_NULL_HANDLER,
45001         ZEND_NULL_HANDLER,
45002         ZEND_NULL_HANDLER,
45003         ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER,
45004         ZEND_NULL_HANDLER,
45005         ZEND_NULL_HANDLER,
45006         ZEND_NULL_HANDLER,
45007         ZEND_NULL_HANDLER,
45008         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45009         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45010         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45011         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45012         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45013         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45014         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45015         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45016         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45017         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45018         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45019         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45020         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45021         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45022         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45023         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45024         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45025         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45026         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45027         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45028         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45029         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45030         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45031         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45032         ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
45033         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45034         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45035         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45036         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45037         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45038         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45039         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45040         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45041         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45042         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45043         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45044         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45045         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45046         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45047         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45048         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45049         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45050         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45051         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45052         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45053         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45054         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45055         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45056         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45057         ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
45058         ZEND_NULL_HANDLER,
45059         ZEND_NULL_HANDLER,
45060         ZEND_NULL_HANDLER,
45061         ZEND_NULL_HANDLER,
45062         ZEND_NULL_HANDLER,
45063         ZEND_NULL_HANDLER,
45064         ZEND_NULL_HANDLER,
45065         ZEND_NULL_HANDLER,
45066         ZEND_NULL_HANDLER,
45067         ZEND_NULL_HANDLER,
45068         ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER,
45069         ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER,
45070         ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER,
45071         ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER,
45072         ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER,
45073         ZEND_NULL_HANDLER,
45074         ZEND_NULL_HANDLER,
45075         ZEND_NULL_HANDLER,
45076         ZEND_NULL_HANDLER,
45077         ZEND_NULL_HANDLER,
45078         ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER,
45079         ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER,
45080         ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER,
45081         ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER,
45082         ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER,
45083         ZEND_NULL_HANDLER,
45084         ZEND_NULL_HANDLER,
45085         ZEND_NULL_HANDLER,
45086         ZEND_NULL_HANDLER,
45087         ZEND_NULL_HANDLER,
45088         ZEND_NULL_HANDLER,
45089         ZEND_NULL_HANDLER,
45090         ZEND_NULL_HANDLER,
45091         ZEND_NULL_HANDLER,
45092         ZEND_NULL_HANDLER,
45093         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER,
45094         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER,
45095         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER,
45096         ZEND_NULL_HANDLER,
45097         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER,
45098         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
45099         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER,
45100         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER,
45101         ZEND_NULL_HANDLER,
45102         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
45103         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
45104         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER,
45105         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER,
45106         ZEND_NULL_HANDLER,
45107         ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
45108         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45109         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45110         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45111         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45112         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45113         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45114         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45115         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45116         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45117         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45118         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45119         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45120         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45121         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45122         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45123         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45124         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45125         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45126         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45127         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45128         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45129         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45130         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45131         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45132         ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
45133         ZEND_USER_OPCODE_SPEC_HANDLER,
45134         ZEND_USER_OPCODE_SPEC_HANDLER,
45135         ZEND_USER_OPCODE_SPEC_HANDLER,
45136         ZEND_USER_OPCODE_SPEC_HANDLER,
45137         ZEND_USER_OPCODE_SPEC_HANDLER,
45138         ZEND_USER_OPCODE_SPEC_HANDLER,
45139         ZEND_USER_OPCODE_SPEC_HANDLER,
45140         ZEND_USER_OPCODE_SPEC_HANDLER,
45141         ZEND_USER_OPCODE_SPEC_HANDLER,
45142         ZEND_USER_OPCODE_SPEC_HANDLER,
45143         ZEND_USER_OPCODE_SPEC_HANDLER,
45144         ZEND_USER_OPCODE_SPEC_HANDLER,
45145         ZEND_USER_OPCODE_SPEC_HANDLER,
45146         ZEND_USER_OPCODE_SPEC_HANDLER,
45147         ZEND_USER_OPCODE_SPEC_HANDLER,
45148         ZEND_USER_OPCODE_SPEC_HANDLER,
45149         ZEND_USER_OPCODE_SPEC_HANDLER,
45150         ZEND_USER_OPCODE_SPEC_HANDLER,
45151         ZEND_USER_OPCODE_SPEC_HANDLER,
45152         ZEND_USER_OPCODE_SPEC_HANDLER,
45153         ZEND_USER_OPCODE_SPEC_HANDLER,
45154         ZEND_USER_OPCODE_SPEC_HANDLER,
45155         ZEND_USER_OPCODE_SPEC_HANDLER,
45156         ZEND_USER_OPCODE_SPEC_HANDLER,
45157         ZEND_USER_OPCODE_SPEC_HANDLER,
45158         ZEND_NULL_HANDLER,
45159         ZEND_NULL_HANDLER,
45160         ZEND_NULL_HANDLER,
45161         ZEND_NULL_HANDLER,
45162         ZEND_NULL_HANDLER,
45163         ZEND_NULL_HANDLER,
45164         ZEND_NULL_HANDLER,
45165         ZEND_NULL_HANDLER,
45166         ZEND_NULL_HANDLER,
45167         ZEND_NULL_HANDLER,
45168         ZEND_NULL_HANDLER,
45169         ZEND_NULL_HANDLER,
45170         ZEND_NULL_HANDLER,
45171         ZEND_NULL_HANDLER,
45172         ZEND_NULL_HANDLER,
45173         ZEND_NULL_HANDLER,
45174         ZEND_NULL_HANDLER,
45175         ZEND_NULL_HANDLER,
45176         ZEND_NULL_HANDLER,
45177         ZEND_NULL_HANDLER,
45178         ZEND_NULL_HANDLER,
45179         ZEND_NULL_HANDLER,
45180         ZEND_NULL_HANDLER,
45181         ZEND_NULL_HANDLER,
45182         ZEND_NULL_HANDLER,
45183         ZEND_JMP_SET_SPEC_CONST_HANDLER,
45184         ZEND_JMP_SET_SPEC_CONST_HANDLER,
45185         ZEND_JMP_SET_SPEC_CONST_HANDLER,
45186         ZEND_JMP_SET_SPEC_CONST_HANDLER,
45187         ZEND_JMP_SET_SPEC_CONST_HANDLER,
45188         ZEND_JMP_SET_SPEC_TMP_HANDLER,
45189         ZEND_JMP_SET_SPEC_TMP_HANDLER,
45190         ZEND_JMP_SET_SPEC_TMP_HANDLER,
45191         ZEND_JMP_SET_SPEC_TMP_HANDLER,
45192         ZEND_JMP_SET_SPEC_TMP_HANDLER,
45193         ZEND_JMP_SET_SPEC_VAR_HANDLER,
45194         ZEND_JMP_SET_SPEC_VAR_HANDLER,
45195         ZEND_JMP_SET_SPEC_VAR_HANDLER,
45196         ZEND_JMP_SET_SPEC_VAR_HANDLER,
45197         ZEND_JMP_SET_SPEC_VAR_HANDLER,
45198         ZEND_NULL_HANDLER,
45199         ZEND_NULL_HANDLER,
45200         ZEND_NULL_HANDLER,
45201         ZEND_NULL_HANDLER,
45202         ZEND_NULL_HANDLER,
45203         ZEND_JMP_SET_SPEC_CV_HANDLER,
45204         ZEND_JMP_SET_SPEC_CV_HANDLER,
45205         ZEND_JMP_SET_SPEC_CV_HANDLER,
45206         ZEND_JMP_SET_SPEC_CV_HANDLER,
45207         ZEND_JMP_SET_SPEC_CV_HANDLER,
45208         ZEND_NULL_HANDLER,
45209         ZEND_NULL_HANDLER,
45210         ZEND_NULL_HANDLER,
45211         ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER,
45212         ZEND_NULL_HANDLER,
45213         ZEND_NULL_HANDLER,
45214         ZEND_NULL_HANDLER,
45215         ZEND_NULL_HANDLER,
45216         ZEND_NULL_HANDLER,
45217         ZEND_NULL_HANDLER,
45218         ZEND_NULL_HANDLER,
45219         ZEND_NULL_HANDLER,
45220         ZEND_NULL_HANDLER,
45221         ZEND_NULL_HANDLER,
45222         ZEND_NULL_HANDLER,
45223         ZEND_NULL_HANDLER,
45224         ZEND_NULL_HANDLER,
45225         ZEND_NULL_HANDLER,
45226         ZEND_NULL_HANDLER,
45227         ZEND_NULL_HANDLER,
45228         ZEND_NULL_HANDLER,
45229         ZEND_NULL_HANDLER,
45230         ZEND_NULL_HANDLER,
45231         ZEND_NULL_HANDLER,
45232         ZEND_NULL_HANDLER,
45233         ZEND_ADD_TRAIT_SPEC_HANDLER,
45234         ZEND_ADD_TRAIT_SPEC_HANDLER,
45235         ZEND_ADD_TRAIT_SPEC_HANDLER,
45236         ZEND_ADD_TRAIT_SPEC_HANDLER,
45237         ZEND_ADD_TRAIT_SPEC_HANDLER,
45238         ZEND_ADD_TRAIT_SPEC_HANDLER,
45239         ZEND_ADD_TRAIT_SPEC_HANDLER,
45240         ZEND_ADD_TRAIT_SPEC_HANDLER,
45241         ZEND_ADD_TRAIT_SPEC_HANDLER,
45242         ZEND_ADD_TRAIT_SPEC_HANDLER,
45243         ZEND_ADD_TRAIT_SPEC_HANDLER,
45244         ZEND_ADD_TRAIT_SPEC_HANDLER,
45245         ZEND_ADD_TRAIT_SPEC_HANDLER,
45246         ZEND_ADD_TRAIT_SPEC_HANDLER,
45247         ZEND_ADD_TRAIT_SPEC_HANDLER,
45248         ZEND_ADD_TRAIT_SPEC_HANDLER,
45249         ZEND_ADD_TRAIT_SPEC_HANDLER,
45250         ZEND_ADD_TRAIT_SPEC_HANDLER,
45251         ZEND_ADD_TRAIT_SPEC_HANDLER,
45252         ZEND_ADD_TRAIT_SPEC_HANDLER,
45253         ZEND_ADD_TRAIT_SPEC_HANDLER,
45254         ZEND_ADD_TRAIT_SPEC_HANDLER,
45255         ZEND_ADD_TRAIT_SPEC_HANDLER,
45256         ZEND_ADD_TRAIT_SPEC_HANDLER,
45257         ZEND_ADD_TRAIT_SPEC_HANDLER,
45258         ZEND_BIND_TRAITS_SPEC_HANDLER,
45259         ZEND_BIND_TRAITS_SPEC_HANDLER,
45260         ZEND_BIND_TRAITS_SPEC_HANDLER,
45261         ZEND_BIND_TRAITS_SPEC_HANDLER,
45262         ZEND_BIND_TRAITS_SPEC_HANDLER,
45263         ZEND_BIND_TRAITS_SPEC_HANDLER,
45264         ZEND_BIND_TRAITS_SPEC_HANDLER,
45265         ZEND_BIND_TRAITS_SPEC_HANDLER,
45266         ZEND_BIND_TRAITS_SPEC_HANDLER,
45267         ZEND_BIND_TRAITS_SPEC_HANDLER,
45268         ZEND_BIND_TRAITS_SPEC_HANDLER,
45269         ZEND_BIND_TRAITS_SPEC_HANDLER,
45270         ZEND_BIND_TRAITS_SPEC_HANDLER,
45271         ZEND_BIND_TRAITS_SPEC_HANDLER,
45272         ZEND_BIND_TRAITS_SPEC_HANDLER,
45273         ZEND_BIND_TRAITS_SPEC_HANDLER,
45274         ZEND_BIND_TRAITS_SPEC_HANDLER,
45275         ZEND_BIND_TRAITS_SPEC_HANDLER,
45276         ZEND_BIND_TRAITS_SPEC_HANDLER,
45277         ZEND_BIND_TRAITS_SPEC_HANDLER,
45278         ZEND_BIND_TRAITS_SPEC_HANDLER,
45279         ZEND_BIND_TRAITS_SPEC_HANDLER,
45280         ZEND_BIND_TRAITS_SPEC_HANDLER,
45281         ZEND_BIND_TRAITS_SPEC_HANDLER,
45282         ZEND_BIND_TRAITS_SPEC_HANDLER,
45283         ZEND_NULL_HANDLER,
45284         ZEND_NULL_HANDLER,
45285         ZEND_NULL_HANDLER,
45286         ZEND_NULL_HANDLER,
45287         ZEND_NULL_HANDLER,
45288         ZEND_NULL_HANDLER,
45289         ZEND_NULL_HANDLER,
45290         ZEND_NULL_HANDLER,
45291         ZEND_NULL_HANDLER,
45292         ZEND_NULL_HANDLER,
45293         ZEND_NULL_HANDLER,
45294         ZEND_NULL_HANDLER,
45295         ZEND_NULL_HANDLER,
45296         ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
45297         ZEND_NULL_HANDLER,
45298         ZEND_NULL_HANDLER,
45299         ZEND_NULL_HANDLER,
45300         ZEND_NULL_HANDLER,
45301         ZEND_NULL_HANDLER,
45302         ZEND_NULL_HANDLER,
45303         ZEND_NULL_HANDLER,
45304         ZEND_NULL_HANDLER,
45305         ZEND_NULL_HANDLER,
45306         ZEND_NULL_HANDLER,
45307         ZEND_NULL_HANDLER,
45308         ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45309         ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45310         ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45311         ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45312         ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER,
45313         ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45314         ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45315         ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45316         ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45317         ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER,
45318         ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45319         ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45320         ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45321         ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45322         ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER,
45323         ZEND_NULL_HANDLER,
45324         ZEND_NULL_HANDLER,
45325         ZEND_NULL_HANDLER,
45326         ZEND_NULL_HANDLER,
45327         ZEND_NULL_HANDLER,
45328         ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45329         ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45330         ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45331         ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45332         ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER,
45333         ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45334         ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45335         ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45336         ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45337         ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER,
45338         ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45339         ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45340         ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45341         ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45342         ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER,
45343         ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45344         ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45345         ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45346         ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45347         ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER,
45348         ZEND_NULL_HANDLER,
45349         ZEND_NULL_HANDLER,
45350         ZEND_NULL_HANDLER,
45351         ZEND_NULL_HANDLER,
45352         ZEND_NULL_HANDLER,
45353         ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45354         ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45355         ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45356         ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45357         ZEND_JMP_SET_VAR_SPEC_CV_HANDLER,
45358         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45359         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45360         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45361         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45362         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45363         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45364         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45365         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45366         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45367         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45368         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45369         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45370         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45371         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45372         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45373         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45374         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45375         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45376         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45377         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45378         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45379         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45380         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45381         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45382         ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
45383         ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
45384         ZEND_YIELD_SPEC_CONST_TMP_HANDLER,
45385         ZEND_YIELD_SPEC_CONST_VAR_HANDLER,
45386         ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER,
45387         ZEND_YIELD_SPEC_CONST_CV_HANDLER,
45388         ZEND_YIELD_SPEC_TMP_CONST_HANDLER,
45389         ZEND_YIELD_SPEC_TMP_TMP_HANDLER,
45390         ZEND_YIELD_SPEC_TMP_VAR_HANDLER,
45391         ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER,
45392         ZEND_YIELD_SPEC_TMP_CV_HANDLER,
45393         ZEND_YIELD_SPEC_VAR_CONST_HANDLER,
45394         ZEND_YIELD_SPEC_VAR_TMP_HANDLER,
45395         ZEND_YIELD_SPEC_VAR_VAR_HANDLER,
45396         ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER,
45397         ZEND_YIELD_SPEC_VAR_CV_HANDLER,
45398         ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER,
45399         ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER,
45400         ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER,
45401         ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER,
45402         ZEND_YIELD_SPEC_UNUSED_CV_HANDLER,
45403         ZEND_YIELD_SPEC_CV_CONST_HANDLER,
45404         ZEND_YIELD_SPEC_CV_TMP_HANDLER,
45405         ZEND_YIELD_SPEC_CV_VAR_HANDLER,
45406         ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
45407         ZEND_YIELD_SPEC_CV_CV_HANDLER,
45408         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45409         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45410         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45411         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45412         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45413         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45414         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45415         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45416         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45417         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45418         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45419         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45420         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45421         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45422         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45423         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45424         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45425         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45426         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45427         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45428         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45429         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45430         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45431         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45432         ZEND_GENERATOR_RETURN_SPEC_HANDLER,
45433         ZEND_FAST_CALL_SPEC_HANDLER,
45434         ZEND_FAST_CALL_SPEC_HANDLER,
45435         ZEND_FAST_CALL_SPEC_HANDLER,
45436         ZEND_FAST_CALL_SPEC_HANDLER,
45437         ZEND_FAST_CALL_SPEC_HANDLER,
45438         ZEND_FAST_CALL_SPEC_HANDLER,
45439         ZEND_FAST_CALL_SPEC_HANDLER,
45440         ZEND_FAST_CALL_SPEC_HANDLER,
45441         ZEND_FAST_CALL_SPEC_HANDLER,
45442         ZEND_FAST_CALL_SPEC_HANDLER,
45443         ZEND_FAST_CALL_SPEC_HANDLER,
45444         ZEND_FAST_CALL_SPEC_HANDLER,
45445         ZEND_FAST_CALL_SPEC_HANDLER,
45446         ZEND_FAST_CALL_SPEC_HANDLER,
45447         ZEND_FAST_CALL_SPEC_HANDLER,
45448         ZEND_FAST_CALL_SPEC_HANDLER,
45449         ZEND_FAST_CALL_SPEC_HANDLER,
45450         ZEND_FAST_CALL_SPEC_HANDLER,
45451         ZEND_FAST_CALL_SPEC_HANDLER,
45452         ZEND_FAST_CALL_SPEC_HANDLER,
45453         ZEND_FAST_CALL_SPEC_HANDLER,
45454         ZEND_FAST_CALL_SPEC_HANDLER,
45455         ZEND_FAST_CALL_SPEC_HANDLER,
45456         ZEND_FAST_CALL_SPEC_HANDLER,
45457         ZEND_FAST_CALL_SPEC_HANDLER,
45458         ZEND_FAST_RET_SPEC_HANDLER,
45459         ZEND_FAST_RET_SPEC_HANDLER,
45460         ZEND_FAST_RET_SPEC_HANDLER,
45461         ZEND_FAST_RET_SPEC_HANDLER,
45462         ZEND_FAST_RET_SPEC_HANDLER,
45463         ZEND_FAST_RET_SPEC_HANDLER,
45464         ZEND_FAST_RET_SPEC_HANDLER,
45465         ZEND_FAST_RET_SPEC_HANDLER,
45466         ZEND_FAST_RET_SPEC_HANDLER,
45467         ZEND_FAST_RET_SPEC_HANDLER,
45468         ZEND_FAST_RET_SPEC_HANDLER,
45469         ZEND_FAST_RET_SPEC_HANDLER,
45470         ZEND_FAST_RET_SPEC_HANDLER,
45471         ZEND_FAST_RET_SPEC_HANDLER,
45472         ZEND_FAST_RET_SPEC_HANDLER,
45473         ZEND_FAST_RET_SPEC_HANDLER,
45474         ZEND_FAST_RET_SPEC_HANDLER,
45475         ZEND_FAST_RET_SPEC_HANDLER,
45476         ZEND_FAST_RET_SPEC_HANDLER,
45477         ZEND_FAST_RET_SPEC_HANDLER,
45478         ZEND_FAST_RET_SPEC_HANDLER,
45479         ZEND_FAST_RET_SPEC_HANDLER,
45480         ZEND_FAST_RET_SPEC_HANDLER,
45481         ZEND_FAST_RET_SPEC_HANDLER,
45482         ZEND_FAST_RET_SPEC_HANDLER,
45483         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45484         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45485         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45486         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45487         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45488         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45489         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45490         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45491         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45492         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45493         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45494         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45495         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45496         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45497         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45498         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45499         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45500         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45501         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45502         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45503         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45504         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45505         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45506         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45507         ZEND_RECV_VARIADIC_SPEC_HANDLER,
45508         ZEND_SEND_UNPACK_SPEC_HANDLER,
45509         ZEND_SEND_UNPACK_SPEC_HANDLER,
45510         ZEND_SEND_UNPACK_SPEC_HANDLER,
45511         ZEND_SEND_UNPACK_SPEC_HANDLER,
45512         ZEND_SEND_UNPACK_SPEC_HANDLER,
45513         ZEND_SEND_UNPACK_SPEC_HANDLER,
45514         ZEND_SEND_UNPACK_SPEC_HANDLER,
45515         ZEND_SEND_UNPACK_SPEC_HANDLER,
45516         ZEND_SEND_UNPACK_SPEC_HANDLER,
45517         ZEND_SEND_UNPACK_SPEC_HANDLER,
45518         ZEND_SEND_UNPACK_SPEC_HANDLER,
45519         ZEND_SEND_UNPACK_SPEC_HANDLER,
45520         ZEND_SEND_UNPACK_SPEC_HANDLER,
45521         ZEND_SEND_UNPACK_SPEC_HANDLER,
45522         ZEND_SEND_UNPACK_SPEC_HANDLER,
45523         ZEND_SEND_UNPACK_SPEC_HANDLER,
45524         ZEND_SEND_UNPACK_SPEC_HANDLER,
45525         ZEND_SEND_UNPACK_SPEC_HANDLER,
45526         ZEND_SEND_UNPACK_SPEC_HANDLER,
45527         ZEND_SEND_UNPACK_SPEC_HANDLER,
45528         ZEND_SEND_UNPACK_SPEC_HANDLER,
45529         ZEND_SEND_UNPACK_SPEC_HANDLER,
45530         ZEND_SEND_UNPACK_SPEC_HANDLER,
45531         ZEND_SEND_UNPACK_SPEC_HANDLER,
45532         ZEND_SEND_UNPACK_SPEC_HANDLER,
45533         ZEND_POW_SPEC_CONST_CONST_HANDLER,
45534         ZEND_POW_SPEC_CONST_TMP_HANDLER,
45535         ZEND_POW_SPEC_CONST_VAR_HANDLER,
45536         ZEND_NULL_HANDLER,
45537         ZEND_POW_SPEC_CONST_CV_HANDLER,
45538         ZEND_POW_SPEC_TMP_CONST_HANDLER,
45539         ZEND_POW_SPEC_TMP_TMP_HANDLER,
45540         ZEND_POW_SPEC_TMP_VAR_HANDLER,
45541         ZEND_NULL_HANDLER,
45542         ZEND_POW_SPEC_TMP_CV_HANDLER,
45543         ZEND_POW_SPEC_VAR_CONST_HANDLER,
45544         ZEND_POW_SPEC_VAR_TMP_HANDLER,
45545         ZEND_POW_SPEC_VAR_VAR_HANDLER,
45546         ZEND_NULL_HANDLER,
45547         ZEND_POW_SPEC_VAR_CV_HANDLER,
45548         ZEND_NULL_HANDLER,
45549         ZEND_NULL_HANDLER,
45550         ZEND_NULL_HANDLER,
45551         ZEND_NULL_HANDLER,
45552         ZEND_NULL_HANDLER,
45553         ZEND_POW_SPEC_CV_CONST_HANDLER,
45554         ZEND_POW_SPEC_CV_TMP_HANDLER,
45555         ZEND_POW_SPEC_CV_VAR_HANDLER,
45556         ZEND_NULL_HANDLER,
45557         ZEND_POW_SPEC_CV_CV_HANDLER,
45558         ZEND_NULL_HANDLER,
45559         ZEND_NULL_HANDLER,
45560         ZEND_NULL_HANDLER,
45561         ZEND_NULL_HANDLER,
45562         ZEND_NULL_HANDLER,
45563         ZEND_NULL_HANDLER,
45564         ZEND_NULL_HANDLER,
45565         ZEND_NULL_HANDLER,
45566         ZEND_NULL_HANDLER,
45567         ZEND_NULL_HANDLER,
45568         ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER,
45569         ZEND_ASSIGN_POW_SPEC_VAR_TMP_HANDLER,
45570         ZEND_ASSIGN_POW_SPEC_VAR_VAR_HANDLER,
45571         ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_HANDLER,
45572         ZEND_ASSIGN_POW_SPEC_VAR_CV_HANDLER,
45573         ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_HANDLER,
45574         ZEND_ASSIGN_POW_SPEC_UNUSED_TMP_HANDLER,
45575         ZEND_ASSIGN_POW_SPEC_UNUSED_VAR_HANDLER,
45576         ZEND_ASSIGN_POW_SPEC_UNUSED_UNUSED_HANDLER,
45577         ZEND_ASSIGN_POW_SPEC_UNUSED_CV_HANDLER,
45578         ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER,
45579         ZEND_ASSIGN_POW_SPEC_CV_TMP_HANDLER,
45580         ZEND_ASSIGN_POW_SPEC_CV_VAR_HANDLER,
45581         ZEND_ASSIGN_POW_SPEC_CV_UNUSED_HANDLER,
45582         ZEND_ASSIGN_POW_SPEC_CV_CV_HANDLER,
45583         ZEND_NULL_HANDLER
45584   };
45585   zend_opcode_handlers = (opcode_handler_t*)labels;
45586 }
45587 static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op)
45588 {
45589                 static const int zend_vm_decode[] = {
45590                         _UNUSED_CODE, /* 0              */
45591                         _CONST_CODE,  /* 1 = IS_CONST   */
45592                         _TMP_CODE,    /* 2 = IS_TMP_VAR */
45593                         _UNUSED_CODE, /* 3              */
45594                         _VAR_CODE,    /* 4 = IS_VAR     */
45595                         _UNUSED_CODE, /* 5              */
45596                         _UNUSED_CODE, /* 6              */
45597                         _UNUSED_CODE, /* 7              */
45598                         _UNUSED_CODE, /* 8 = IS_UNUSED  */
45599                         _UNUSED_CODE, /* 9              */
45600                         _UNUSED_CODE, /* 10             */
45601                         _UNUSED_CODE, /* 11             */
45602                         _UNUSED_CODE, /* 12             */
45603                         _UNUSED_CODE, /* 13             */
45604                         _UNUSED_CODE, /* 14             */
45605                         _UNUSED_CODE, /* 15             */
45606                         _CV_CODE      /* 16 = IS_CV     */
45607                 };
45608                 return zend_opcode_handlers[opcode * 25 + zend_vm_decode[op->op1_type] * 5 + zend_vm_decode[op->op2_type]];
45609 }
45610 
45611 ZEND_API void zend_vm_set_opcode_handler(zend_op* op)
45612 {
45613         op->handler = zend_vm_get_opcode_handler(zend_user_opcodes[op->opcode], op);
45614 }
45615 
45616 ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS)
45617 {
45618         return zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
45619 }
45620
/* [<][>][^][v][top][bottom][index][help] */