Index: zend_execute.c
===================================================================
RCS file: /repository/ZendEngine2/zend_execute.c,v
retrieving revision 1.716.2.6
diff -u -r1.716.2.6 zend_execute.c
--- zend_execute.c	16 Nov 2005 11:52:26 -0000	1.716.2.6
+++ zend_execute.c	28 Nov 2005 16:14:08 -0000
@@ -1359,22 +1359,27 @@
 
 #define ZEND_VM_NEXT_OPCODE() \
      CHECK_SYMBOL_TABLES() \
-     EX(opline)++; \
+     EX(opline)++;\
+	 ZEND_UPDATE_OPLINE(); \
      ZEND_VM_CONTINUE()
 
 #define ZEND_VM_SET_OPCODE(new_op) \
      CHECK_SYMBOL_TABLES() \
-     EX(opline) = new_op
+     EX(opline) = new_op; \
+	 ZEND_UPDATE_VARS(); \
+	 ZEND_UPDATE_OPLINE()
 
 #define ZEND_VM_JMP(new_op) \
      CHECK_SYMBOL_TABLES() \
  	   EX(opline) = EG(exception)?EX(opline)+1:new_op; \
+	   ZEND_UPDATE_OPLINE(); \
      ZEND_VM_CONTINUE()
 
 #define ZEND_VM_INC_OPCODE() \
      if (!EG(exception)) { \
        CHECK_SYMBOL_TABLES() \
        EX(opline)++; \
+	   ZEND_UPDATE_OPLINE(); \
      }
 
 #define ZEND_VM_RETURN_FROM_EXECUTE_LOOP() \
Index: zend_vm_gen.php
===================================================================
RCS file: /repository/ZendEngine2/zend_vm_gen.php,v
retrieving revision 1.12.2.2
diff -u -r1.12.2.2 zend_vm_gen.php
--- zend_vm_gen.php	26 Nov 2005 06:22:14 -0000	1.12.2.2
+++ zend_vm_gen.php	28 Nov 2005 16:14:09 -0000
@@ -785,6 +785,10 @@
 					out($f,"static opcode_handler_t zend_vm_get_opcode_handler(zend_uchar opcode, zend_op* op);\n\n");
 					switch ($kind) {
 						case ZEND_VM_KIND_CALL:
+							out($f, "#define ZEND_LOAD_CONTEXT() zend_op * opline = EX(opline)\n");
+							out($f, "#define EX_T_OPLINE(element) EX_T(opline->element)\n\n");
+							out($f, "#define ZEND_UPDATE_OPLINE() do {} while(0) \n");
+							out($f, "#define ZEND_UPDATE_VARS() do {} while(0) \n");
 							out($f,"\n");
 							out($f,"#define ZEND_VM_CONTINUE()   return 0\n");
 							out($f,"#define ZEND_VM_RETURN()     return 1\n");
@@ -792,6 +796,10 @@
 							out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC\n");
 							break;
 						case ZEND_VM_KIND_SWITCH:
+							out($f, "#define ZEND_LOAD_CONTEXT() unsigned cheques_are_no_good\n");
+							out($f, "#define EX_T_OPLINE(element) (*(temp_variable*)((char *)vars + (opline->element)))\n\n");
+							out($f, "#define ZEND_UPDATE_OPLINE() opline = EX(opline) \n");
+							out($f, "#define ZEND_UPDATE_VARS() vars = EX(Ts) \n");
 							out($f,"\n");
 							out($f,"#define ZEND_VM_CONTINUE() goto zend_vm_continue\n");
 							out($f,"#define ZEND_VM_RETURN()   return\n");
@@ -799,8 +807,12 @@
 							out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL &execute_data TSRMLS_CC\n");
 							break;
 						case ZEND_VM_KIND_GOTO:
+							out($f, "#define ZEND_LOAD_CONTEXT() unsigned cheques_are_no_good\n");
+							out($f, "#define EX_T_OPLINE(element) (*(temp_variable*)((char *)vars + (opline->element)))\n\n");
+							out($f, "#define ZEND_UPDATE_OPLINE() opline = EX(opline) \n");
+							out($f, "#define ZEND_UPDATE_VARS() vars = EX(Ts) \n");
 							out($f,"\n");
-							out($f,"#define ZEND_VM_CONTINUE() goto *(void**)(EX(opline)->handler)\n");
+							out($f,"#define ZEND_VM_CONTINUE() goto *(void**)(opline->handler)\n");
 							out($f,"#define ZEND_VM_RETURN()   return\n");
 							out($f,"#define ZEND_VM_DISPATCH(opcode, opline) goto *(void**)(zend_vm_get_opcode_handler(opcode, opline));\n\n");
 							out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL &execute_data TSRMLS_CC\n");
@@ -815,6 +827,16 @@
 						if ($kind == ZEND_VM_KIND_SWITCH) {
 							out($f,$m[1]."opcode_handler_t dispatch_handler;\n");
 						}
+						if ($kind == ZEND_VM_KIND_GOTO || $kind == ZEND_VM_KIND_SWITCH) {
+						
+							out($f,$m[1]." register zend_op * opline\n");
+							out($f,$m[1]."#if defined(__i386__) && defined(__GNUC__) \n");
+							out($f, $m[1]." asm(\"esi\")\n");
+							out($f,$m[1]."#endif\n");
+							out($f, $m[1].";\n");
+							out($f,$m[1]." register temp_variable * vars\n");
+							out($f, $m[1]."= NULL;\n");
+						}
 					  // Emit local variables those are used for helpers' parameters
 						foreach ($params as $param => $x) {
 							out($f,$m[1].$param.";\n");
@@ -1210,8 +1232,12 @@
 					$done = 1;
 				}
 			}
-		}
+		} 
 		if (!$done) {
+			if (ZEND_VM_KIND == ZEND_VM_KIND_GOTO || ZEND_VM_KIND == ZEND_VM_KIND_SWITCH) {
+				out($f, "#undef ZEND_LOAD_CONTEXT \n");
+				out($f, "#define ZEND_LOAD_CONTEXT() zend_op * opline = EX(opline); temp_variable * vars = EX(Ts)\n\n");
+			}
 			gen_code($f, 0, ZEND_VM_KIND_CALL, $code, 'ANY', 'ANY');
 		}
 	}
Index: zend_vm_def.h
===================================================================
RCS file: /repository/ZendEngine2/zend_vm_def.h,v
retrieving revision 1.59.2.19
diff -u -r1.59.2.19 zend_vm_def.h
--- zend_vm_def.h	31 Oct 2005 19:25:10 -0000	1.59.2.19
+++ zend_vm_def.h	28 Nov 2005 16:14:10 -0000
@@ -27,10 +27,10 @@
 
 ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	add_function(&EX_T(opline->result.u.var).tmp_var,
+	add_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -40,10 +40,10 @@
 
 ZEND_VM_HANDLER(2, ZEND_SUB, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	sub_function(&EX_T(opline->result.u.var).tmp_var,
+	sub_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -53,10 +53,10 @@
 
 ZEND_VM_HANDLER(3, ZEND_MUL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	mul_function(&EX_T(opline->result.u.var).tmp_var,
+	mul_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -66,10 +66,10 @@
 
 ZEND_VM_HANDLER(4, ZEND_DIV, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	div_function(&EX_T(opline->result.u.var).tmp_var,
+	div_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -79,10 +79,10 @@
 
 ZEND_VM_HANDLER(5, ZEND_MOD, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	mod_function(&EX_T(opline->result.u.var).tmp_var,
+	mod_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -92,10 +92,10 @@
 
 ZEND_VM_HANDLER(6, ZEND_SL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	shift_left_function(&EX_T(opline->result.u.var).tmp_var,
+	shift_left_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -105,10 +105,10 @@
 
 ZEND_VM_HANDLER(7, ZEND_SR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	shift_right_function(&EX_T(opline->result.u.var).tmp_var,
+	shift_right_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -118,10 +118,10 @@
 
 ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	concat_function(&EX_T(opline->result.u.var).tmp_var,
+	concat_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -131,10 +131,10 @@
 
 ZEND_VM_HANDLER(15, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	is_identical_function(&EX_T(opline->result.u.var).tmp_var,
+	is_identical_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -144,10 +144,10 @@
 
 ZEND_VM_HANDLER(16, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	is_not_identical_function(&EX_T(opline->result.u.var).tmp_var,
+	is_not_identical_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -157,10 +157,10 @@
 
 ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	is_equal_function(&EX_T(opline->result.u.var).tmp_var,
+	is_equal_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -170,10 +170,10 @@
 
 ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	is_not_equal_function(&EX_T(opline->result.u.var).tmp_var,
+	is_not_equal_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -183,10 +183,10 @@
 
 ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	is_smaller_function(&EX_T(opline->result.u.var).tmp_var,
+	is_smaller_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -196,10 +196,10 @@
 
 ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	is_smaller_or_equal_function(&EX_T(opline->result.u.var).tmp_var,
+	is_smaller_or_equal_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -209,10 +209,10 @@
 
 ZEND_VM_HANDLER(9, ZEND_BW_OR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	bitwise_or_function(&EX_T(opline->result.u.var).tmp_var,
+	bitwise_or_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -222,10 +222,10 @@
 
 ZEND_VM_HANDLER(10, ZEND_BW_AND, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	bitwise_and_function(&EX_T(opline->result.u.var).tmp_var,
+	bitwise_and_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -235,10 +235,10 @@
 
 ZEND_VM_HANDLER(11, ZEND_BW_XOR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	bitwise_xor_function(&EX_T(opline->result.u.var).tmp_var,
+	bitwise_xor_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -248,10 +248,10 @@
 
 ZEND_VM_HANDLER(14, ZEND_BOOL_XOR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 
-	boolean_xor_function(&EX_T(opline->result.u.var).tmp_var,
+	boolean_xor_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -261,10 +261,10 @@
 
 ZEND_VM_HANDLER(12, ZEND_BW_NOT, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 
-	bitwise_not_function(&EX_T(opline->result.u.var).tmp_var,
+	bitwise_not_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	ZEND_VM_NEXT_OPCODE();
@@ -272,10 +272,10 @@
 
 ZEND_VM_HANDLER(13, ZEND_BOOL_NOT, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 
-	boolean_not_function(&EX_T(opline->result.u.var).tmp_var,
+	boolean_not_function(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	ZEND_VM_NEXT_OPCODE();
@@ -283,7 +283,7 @@
 
 ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_op *op_data = opline+1;
 	zend_free_op free_op1, free_op2, free_op_data1;
 	zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
@@ -395,7 +395,7 @@
 
 ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
 	zval **var_ptr;
 	zval *value;
@@ -438,9 +438,9 @@
 
 	if (*var_ptr == EG(error_zval_ptr)) {
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
-			EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
-			PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
-			AI_USE_PTR(EX_T(opline->result.u.var).var);
+			EX_T_OPLINE(result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
+			PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
+			AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 		}
 		FREE_OP2();
 		FREE_OP1_VAR_PTR();
@@ -465,9 +465,9 @@
 	}
 
 	if (!RETURN_VALUE_UNUSED(&opline->result)) {
-		EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = var_ptr;
 		PZVAL_LOCK(*var_ptr);
-		AI_USE_PTR(EX_T(opline->result.u.var).var);
+		AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 	}
 	FREE_OP2();
 
@@ -537,12 +537,12 @@
 
 ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, incdec_t incdec_op)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
 	zval *object;
 	zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
-	zval **retval = &EX_T(opline->result.u.var).var.ptr;
+	zval **retval = &EX_T_OPLINE(result.u.var).var.ptr;
 	int have_get_ptr = 0;
 
 	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
@@ -629,12 +629,12 @@
 
 ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, incdec_t incdec_op)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
 	zval *object;
 	zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
-	zval *retval = &EX_T(opline->result.u.var).tmp_var;
+	zval *retval = &EX_T_OPLINE(result.u.var).tmp_var;
 	int have_get_ptr = 0;
 
 	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
@@ -720,7 +720,7 @@
 
 ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
@@ -729,9 +729,9 @@
 	}
 	if (*var_ptr == EG(error_zval_ptr)) {
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
-			EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
-			PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
-			AI_USE_PTR(EX_T(opline->result.u.var).var);
+			EX_T_OPLINE(result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
+			PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
+			AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 		}
 		FREE_OP1_VAR_PTR();
 		ZEND_VM_NEXT_OPCODE();
@@ -752,9 +752,9 @@
 	}
 
 	if (!RETURN_VALUE_UNUSED(&opline->result)) {
-		EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = var_ptr;
 		PZVAL_LOCK(*var_ptr);
-		AI_USE_PTR(EX_T(opline->result.u.var).var);
+		AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 	}
 
 	FREE_OP1_VAR_PTR();
@@ -763,7 +763,7 @@
 
 ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
@@ -772,9 +772,9 @@
 	}
 	if (*var_ptr == EG(error_zval_ptr)) {
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
-			EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
-			PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
-			AI_USE_PTR(EX_T(opline->result.u.var).var);
+			EX_T_OPLINE(result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
+			PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
+			AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 		}
 		FREE_OP1_VAR_PTR();
 		ZEND_VM_NEXT_OPCODE();
@@ -795,9 +795,9 @@
 	}
 
 	if (!RETURN_VALUE_UNUSED(&opline->result)) {
-		EX_T(opline->result.u.var).var.ptr_ptr = var_ptr;
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = var_ptr;
 		PZVAL_LOCK(*var_ptr);
-		AI_USE_PTR(EX_T(opline->result.u.var).var);
+		AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 	}
 
 	FREE_OP1_VAR_PTR();
@@ -806,7 +806,7 @@
 
 ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
@@ -815,14 +815,14 @@
 	}
 	if (*var_ptr == EG(error_zval_ptr)) {
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
-			EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
+			EX_T_OPLINE(result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
 		}
 		FREE_OP1_VAR_PTR();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	EX_T(opline->result.u.var).tmp_var = **var_ptr;
-	zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
+	EX_T_OPLINE(result.u.var).tmp_var = **var_ptr;
+	zendi_zval_copy_ctor(EX_T_OPLINE(result.u.var).tmp_var);
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
 
@@ -844,7 +844,7 @@
 
 ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
@@ -853,14 +853,14 @@
 	}
 	if (*var_ptr == EG(error_zval_ptr)) {
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
-			EX_T(opline->result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
+			EX_T_OPLINE(result.u.var).tmp_var = *EG(uninitialized_zval_ptr);
 		}
 		FREE_OP1_VAR_PTR();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	EX_T(opline->result.u.var).tmp_var = **var_ptr;
-	zendi_zval_copy_ctor(EX_T(opline->result.u.var).tmp_var);
+	EX_T_OPLINE(result.u.var).tmp_var = **var_ptr;
+	zendi_zval_copy_ctor(EX_T_OPLINE(result.u.var).tmp_var);
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
 
@@ -882,7 +882,7 @@
 
 ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval z_copy;
 	zval *z = GET_OP1_ZVAL_PTR(BP_VAR_R);
@@ -901,17 +901,17 @@
 
 ZEND_VM_HANDLER(41, ZEND_PRINT, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 
-	EX_T(opline->result.u.var).tmp_var.value.lval = 1;
-	EX_T(opline->result.u.var).tmp_var.type = IS_LONG;
+	EX_T_OPLINE(result.u.var).tmp_var.value.lval = 1;
+	EX_T_OPLINE(result.u.var).tmp_var.type = IS_LONG;
 
 	ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ECHO);
 }
 
 ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, ANY, int type)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	zval **retval;
@@ -926,7 +926,7 @@
 	}
 
 	if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
-		retval = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
+		retval = zend_std_get_static_property(EX_T_OPLINE(op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0 TSRMLS_CC);
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), type, varname TSRMLS_CC);
 /*
@@ -972,21 +972,21 @@
 		zval_dtor(varname);
 	}
 	if (!RETURN_VALUE_UNUSED(&opline->result)) {
-		EX_T(opline->result.u.var).var.ptr_ptr = retval;
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = retval;
 		PZVAL_LOCK(*retval);
 		switch (type) {
 			case BP_VAR_R:
 			case BP_VAR_IS:
-				AI_USE_PTR(EX_T(opline->result.u.var).var);
+				AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 				break;
 			case BP_VAR_UNSET: {
 				zend_free_op free_res;
 
-				PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
-				if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-					SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
+				PZVAL_UNLOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr, &free_res);
+				if (EX_T_OPLINE(result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
+					SEPARATE_ZVAL_IF_NOT_REF(EX_T_OPLINE(result.u.var).var.ptr_ptr);
 				}
-				PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
+				PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
 				FREE_OP_VAR_PTR(free_res);
 				break;
 			}
@@ -1028,14 +1028,14 @@
 
 ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
 	if (opline->extended_value == ZEND_FETCH_ADD_LOCK && OP1_TYPE != IS_CV) {
-		PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
+		PZVAL_LOCK(*EX_T_OPLINE(op1.u.var).var.ptr_ptr);
 	}
-	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_R), dim, IS_OP2_TMP_FREE(), BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_R), dim, IS_OP2_TMP_FREE(), BP_VAR_R TSRMLS_CC);
 	FREE_OP2();
 	FREE_OP1_VAR_PTR();
 	ZEND_VM_NEXT_OPCODE();
@@ -1043,11 +1043,11 @@
 
 ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_W), dim, IS_OP2_TMP_FREE(), BP_VAR_W TSRMLS_CC);
+	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_W), dim, IS_OP2_TMP_FREE(), BP_VAR_W TSRMLS_CC);
 	FREE_OP2();
 	FREE_OP1_VAR_PTR();
 	ZEND_VM_NEXT_OPCODE();
@@ -1055,11 +1055,11 @@
 
 ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW), dim, IS_OP2_TMP_FREE(), BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW), dim, IS_OP2_TMP_FREE(), BP_VAR_RW TSRMLS_CC);
 	FREE_OP2();
 	FREE_OP1_VAR_PTR();
 	ZEND_VM_NEXT_OPCODE();
@@ -1067,11 +1067,11 @@
 
 ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_IS), dim, IS_OP2_TMP_FREE(), BP_VAR_IS TSRMLS_CC);
+	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), GET_OP1_ZVAL_PTR_PTR(BP_VAR_IS), dim, IS_OP2_TMP_FREE(), BP_VAR_IS TSRMLS_CC);
 	FREE_OP2();
 	FREE_OP1_VAR_PTR();
 	ZEND_VM_NEXT_OPCODE();
@@ -1079,7 +1079,7 @@
 
 ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
 	zval *dim;
@@ -1088,7 +1088,7 @@
 		zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 	}
 	dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
-	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_ZVAL_PTR_PTR(type), dim, IS_OP2_TMP_FREE(), type TSRMLS_CC);
+	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), GET_OP1_ZVAL_PTR_PTR(type), dim, IS_OP2_TMP_FREE(), type TSRMLS_CC);
 	FREE_OP2();
 	FREE_OP1_VAR_PTR();
 	ZEND_VM_NEXT_OPCODE();
@@ -1096,14 +1096,14 @@
 
 ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval **container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_UNSET);
 	zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
 	/* Not needed in DIM_UNSET
 	if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
-		PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
+		PZVAL_LOCK(*EX_T_OPLINE(op1.u.var).var.ptr_ptr);
 	}
 	*/
 	if (OP1_TYPE == IS_CV) {
@@ -1111,19 +1111,19 @@
 			SEPARATE_ZVAL_IF_NOT_REF(container);
 		}
 	}
-	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_UNSET TSRMLS_CC);
+	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_UNSET TSRMLS_CC);
 	FREE_OP2();
 	FREE_OP1_VAR_PTR();
-	if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
+	if (EX_T_OPLINE(result.u.var).var.ptr_ptr == NULL) {
 		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
 	} else {
 		zend_free_op free_res;
 
-		PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
-		if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
+		PZVAL_UNLOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr, &free_res);
+		if (EX_T_OPLINE(result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
+			SEPARATE_ZVAL_IF_NOT_REF(EX_T_OPLINE(result.u.var).var.ptr_ptr);
 		}
-		PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
+		PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
 		FREE_OP_VAR_PTR(free_res);
 	}
 	ZEND_VM_NEXT_OPCODE();
@@ -1131,13 +1131,13 @@
 
 ZEND_VM_HELPER_EX(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, int type)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *container;
 	zval **retval;
 	zend_free_op free_op1;
 
-	retval = &EX_T(opline->result.u.var).var.ptr;
-	EX_T(opline->result.u.var).var.ptr_ptr = retval;
+	retval = &EX_T_OPLINE(result.u.var).var.ptr;
+	EX_T_OPLINE(result.u.var).var.ptr_ptr = retval;
 
 	container = GET_OP1_OBJ_ZVAL_PTR(type);
 
@@ -1145,7 +1145,7 @@
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
 			*retval = EG(error_zval_ptr);
 			PZVAL_LOCK(*retval);
-			AI_USE_PTR(EX_T(opline->result.u.var).var);
+			AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 		}
 		FREE_OP1();
 		ZEND_VM_NEXT_OPCODE();
@@ -1156,7 +1156,7 @@
 		zend_error(E_NOTICE, "Trying to get property of non-object");
 		*retval = EG(uninitialized_zval_ptr);
 		SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
-		AI_USE_PTR(EX_T(opline->result.u.var).var);
+		AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 	} else {
 		zend_free_op free_op2;
 		zval *offset  = GET_OP2_ZVAL_PTR(BP_VAR_R);
@@ -1173,7 +1173,7 @@
 			FREE_ZVAL(*retval);
 		} else {
 			SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
-			AI_USE_PTR(EX_T(opline->result.u.var).var);
+			AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 		}
 
 		if (IS_OP2_TMP_FREE()) {
@@ -1194,19 +1194,19 @@
 
 ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
 	if (opline->extended_value == ZEND_FETCH_ADD_LOCK && OP1_TYPE != IS_CV) {
-		PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
-		EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
+		PZVAL_LOCK(*EX_T_OPLINE(op1.u.var).var.ptr_ptr);
+		EX_T_OPLINE(op1.u.var).var.ptr = *EX_T_OPLINE(op1.u.var).var.ptr_ptr;
 	}
 
 	if (IS_OP2_TMP_FREE()) {
 		MAKE_REAL_ZVAL_PTR(property);
 	}
-	zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W), property, BP_VAR_W TSRMLS_CC);
+	zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W), property, BP_VAR_W TSRMLS_CC);
 	if (IS_OP2_TMP_FREE()) {
 		zval_ptr_dtor(&property);
 	} else {
@@ -1218,14 +1218,14 @@
 
 ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
 	if (IS_OP2_TMP_FREE()) {
 		MAKE_REAL_ZVAL_PTR(property);
 	}
-	zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW), property, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW), property, BP_VAR_RW TSRMLS_CC);
 	if (IS_OP2_TMP_FREE()) {
 		zval_ptr_dtor(&property);
 	} else {
@@ -1242,7 +1242,7 @@
 
 ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 
 	if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
 		/* Behave like FETCH_OBJ_W */
@@ -1252,7 +1252,7 @@
 		if (IS_OP2_TMP_FREE()) {
 			MAKE_REAL_ZVAL_PTR(property);
 		}
-		zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W), property, BP_VAR_W TSRMLS_CC);
+		zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W), property, BP_VAR_W TSRMLS_CC);
 		if (IS_OP2_TMP_FREE()) {
 			zval_ptr_dtor(&property);
 		} else {
@@ -1267,7 +1267,7 @@
 
 ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2, free_res;
 	zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_R);
 	zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
@@ -1280,7 +1280,7 @@
 	if (IS_OP2_TMP_FREE()) {
 		MAKE_REAL_ZVAL_PTR(property);
 	}
-	zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, property, BP_VAR_R TSRMLS_CC);
+	zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T_OPLINE(result.u.var), container, property, BP_VAR_R TSRMLS_CC);
 	if (IS_OP2_TMP_FREE()) {
 		zval_ptr_dtor(&property);
 	} else {
@@ -1288,41 +1288,41 @@
 	}
 	FREE_OP1_VAR_PTR();
 
-	PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.u.var).var.ptr_ptr);
+	PZVAL_UNLOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr, &free_res);
+	if (EX_T_OPLINE(result.u.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
+		SEPARATE_ZVAL_IF_NOT_REF(EX_T_OPLINE(result.u.var).var.ptr_ptr);
 	}
-	PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
+	PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
 	FREE_OP_VAR_PTR(free_res);
 	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(98, ZEND_FETCH_DIM_TMP_VAR, TMP, CONST)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *container = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
 	if (container->type != IS_ARRAY) {
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
-			EX_T(opline->result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
-			PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
+			EX_T_OPLINE(result.u.var).var.ptr_ptr = &EG(uninitialized_zval_ptr);
+			PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
 		}
 	} else {
 		zend_free_op free_op2;
 		zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-		EX_T(opline->result.u.var).var.ptr_ptr = zend_fetch_dimension_address_inner(container->value.ht, dim, BP_VAR_R TSRMLS_CC);
-		SELECTIVE_PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &opline->result);
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = zend_fetch_dimension_address_inner(container->value.ht, dim, BP_VAR_R TSRMLS_CC);
+		SELECTIVE_PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr, &opline->result);
 		FREE_OP2();
 	}
-	AI_USE_PTR(EX_T(opline->result.u.var).var);
+	AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_op *op_data = opline+1;
 	zend_free_op free_op1;
 	zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
@@ -1336,12 +1336,12 @@
 
 ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_op *op_data = opline+1;
 	zend_free_op free_op1;
 	zval **object_ptr;
 
-	if (OP1_TYPE == IS_CV || EX_T(opline->op1.u.var).var.ptr_ptr) {
+	if (OP1_TYPE == IS_CV || EX_T_OPLINE(op1.u.var).var.ptr_ptr) {
 		/* not an array offset */
 		object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
 	} else {
@@ -1370,7 +1370,7 @@
 
 ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op2;
 	zval *value = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
@@ -1383,7 +1383,7 @@
 
 ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval **variable_ptr_ptr;
 	zval **value_ptr_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
@@ -1392,14 +1392,14 @@
 	    value_ptr_ptr &&
 	    !(*value_ptr_ptr)->is_ref &&
 	    opline->extended_value == ZEND_RETURNS_FUNCTION && 
-	    !EX_T(opline->op2.u.var).var.fcall_returned_reference) {
+	    !EX_T_OPLINE(op2.u.var).var.fcall_returned_reference) {
 		if (free_op2.var == NULL) {
 			PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
 		}
 		zend_error(E_STRICT, "Only variables should be assigned by reference");
 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ASSIGN);
 	}
-	if (OP1_TYPE == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
+	if (OP1_TYPE == IS_VAR && EX_T_OPLINE(op1.u.var).var.ptr_ptr == &EX_T_OPLINE(op1.u.var).var.ptr) {
 		zend_error(E_ERROR, "Cannot assign by reference to overloaded object");
 	}
 
@@ -1407,9 +1407,9 @@
 	zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
 
 	if (!RETURN_VALUE_UNUSED(&opline->result)) {
-		EX_T(opline->result.u.var).var.ptr_ptr = variable_ptr_ptr;
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = variable_ptr_ptr;
 		PZVAL_LOCK(*variable_ptr_ptr);
-		AI_USE_PTR(EX_T(opline->result.u.var).var);
+		AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 	}
 
 	FREE_OP1_VAR_PTR();
@@ -1429,7 +1429,7 @@
 
 ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	int ret = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
 
@@ -1446,7 +1446,7 @@
 
 ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	int ret = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
 
@@ -1463,7 +1463,7 @@
 
 ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	int retval = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
 
@@ -1483,13 +1483,13 @@
 
 ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	int retval = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
 
 	FREE_OP1();
-	EX_T(opline->result.u.var).tmp_var.value.lval = retval;
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	EX_T_OPLINE(result.u.var).tmp_var.value.lval = retval;
+	EX_T_OPLINE(result.u.var).tmp_var.type = IS_BOOL;
 	if (!retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
@@ -1501,13 +1501,13 @@
 
 ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	int retval = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
 
 	FREE_OP1();
-	EX_T(opline->result.u.var).tmp_var.value.lval = retval;
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	EX_T_OPLINE(result.u.var).tmp_var.value.lval = retval;
+	EX_T_OPLINE(result.u.var).tmp_var.type = IS_BOOL;
 	if (retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.u.opline_num);
@@ -1538,10 +1538,10 @@
 
 ZEND_VM_HANDLER(54, ZEND_ADD_CHAR, TMP, CONST)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 
-	add_char_to_string(&EX_T(opline->result.u.var).tmp_var,
+	add_char_to_string(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_NA),
 		&opline->op2.u.constant);
 	/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
@@ -1550,10 +1550,10 @@
 
 ZEND_VM_HANDLER(55, ZEND_ADD_STRING, TMP, CONST)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 
-	add_string_to_string(&EX_T(opline->result.u.var).tmp_var,
+	add_string_to_string(&EX_T_OPLINE(result.u.var).tmp_var,
 		GET_OP1_ZVAL_PTR(BP_VAR_NA),
 		&opline->op2.u.constant);
 	/* FREE_OP is missing intentionally here - we're always working on the same temporary variable */
@@ -1562,7 +1562,7 @@
 
 ZEND_VM_HANDLER(56, ZEND_ADD_VAR, TMP, TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval *var = GET_OP2_ZVAL_PTR(BP_VAR_R);
 	zval var_copy;
@@ -1572,7 +1572,7 @@
 	if (use_copy) {
 		var = &var_copy;
 	}
-	add_string_to_string(	&EX_T(opline->result.u.var).tmp_var,
+	add_string_to_string(	&EX_T_OPLINE(result.u.var).tmp_var,
 							GET_OP1_ZVAL_PTR(BP_VAR_NA),
 							var);
 	if (use_copy) {
@@ -1591,13 +1591,13 @@
 
 ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *class_name;
 	zend_free_op free_op2;
 
 
 	if (OP2_TYPE == IS_UNUSED) {
-		EX_T(opline->result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
+		EX_T_OPLINE(result.u.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
 		ZEND_VM_NEXT_OPCODE();
 	}
 
@@ -1605,10 +1605,10 @@
 
 	switch (class_name->type) {
 		case IS_OBJECT:
-			EX_T(opline->result.u.var).class_entry = Z_OBJCE_P(class_name);
+			EX_T_OPLINE(result.u.var).class_entry = Z_OBJCE_P(class_name);
 			break;
 		case IS_STRING:
-			EX_T(opline->result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
+			EX_T_OPLINE(result.u.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
 			break;
 		default:
 			zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
@@ -1621,7 +1621,7 @@
 
 ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *function_name;
 	char *function_name_strval;
 	int function_name_strlen;
@@ -1676,13 +1676,13 @@
 
 ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, ANY, CONST|TMP|VAR|UNUSED|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *function_name;
 	zend_class_entry *ce;
 
 	zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
 
-	ce = EX_T(opline->op1.u.var).class_entry;
+	ce = EX_T_OPLINE(op1.u.var).class_entry;
 	if(OP2_TYPE != IS_UNUSED) {
 		char *function_name_strval;
 		int function_name_strlen;
@@ -1728,7 +1728,7 @@
 
 ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *function_name;
 	zend_function *function;
 	char *function_name_strval, *lcname;
@@ -1771,7 +1771,7 @@
 
 ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval **original_return_value;
 	zend_class_entry *current_scope;
 	zval *current_this;
@@ -1963,7 +1963,7 @@
 
 ZEND_VM_HANDLER(60, ZEND_DO_FCALL, CONST, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *fname = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
@@ -1981,7 +1981,7 @@
 
 ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *retval_ptr;
 	zval **retval_ptr_ptr;
 	zend_free_op free_op1;
@@ -2002,8 +2002,8 @@
 
 		if (OP1_TYPE == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
 			if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-			    EX_T(opline->op1.u.var).var.fcall_returned_reference) {
-			} else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
+			    EX_T_OPLINE(op1.u.var).var.fcall_returned_reference) {
+			} else if (EX_T_OPLINE(op1.u.var).var.ptr_ptr == &EX_T_OPLINE(op1.u.var).var.ptr) {
 				if (OP1_TYPE == IS_VAR && !OP1_FREE) {
 					PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
 				}
@@ -2066,7 +2066,7 @@
 
 ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *value;
 	zval *exception;
 	zend_free_op free_op1;
@@ -2090,7 +2090,7 @@
 
 ZEND_VM_HANDLER(107, ZEND_CATCH, ANY, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_class_entry *ce;
 
 	/* Check whether an exception has been thrown, if not, jump over code */
@@ -2099,8 +2099,8 @@
 		ZEND_VM_CONTINUE(); /* CHECK_ME */
 	}
 	ce = Z_OBJCE_P(EG(exception));
-	if (ce != EX_T(opline->op1.u.var).class_entry) {
-		if (!instanceof_function(ce, EX_T(opline->op1.u.var).class_entry TSRMLS_CC)) {
+	if (ce != EX_T_OPLINE(op1.u.var).class_entry) {
+		if (!instanceof_function(ce, EX_T_OPLINE(op1.u.var).class_entry TSRMLS_CC)) {
 			if (opline->op1.u.EA.type) {
 				zend_throw_exception_internal(NULL TSRMLS_CC);
 				ZEND_VM_NEXT_OPCODE();
@@ -2118,7 +2118,7 @@
 
 ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
 		&& ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
 			zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
@@ -2143,7 +2143,7 @@
 
 ZEND_VM_HELPER(zend_send_by_var_helper, VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *varptr;
 	zend_free_op free_op1;
 	varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
@@ -2170,7 +2170,7 @@
 
 ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *varptr;
 
@@ -2184,7 +2184,7 @@
 	
 	varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
-	     EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
+	     EX_T_OPLINE(op1.u.var).var.fcall_returned_reference) &&
 	    varptr != &EG(uninitialized_zval) && 
 	    (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) {
 		varptr->is_ref = 1;
@@ -2207,7 +2207,7 @@
 
 ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval **varptr_ptr;
 	zval *varptr;
@@ -2228,7 +2228,7 @@
 
 ZEND_VM_HANDLER(66, ZEND_SEND_VAR, VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 
 	if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME)
 		&& ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
@@ -2239,7 +2239,7 @@
 
 ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval **param;
 	zend_uint arg_num = opline->op1.u.constant.value.lval;
 
@@ -2255,7 +2255,7 @@
 			zend_error(E_WARNING, "Missing argument %ld for %s%s%s()", opline->op1.u.constant.value.lval, class_name, space, get_active_function_name(TSRMLS_C));
 		}
 		if (opline->result.op_type == IS_VAR) {
-			PZVAL_UNLOCK_FREE(*EX_T(opline->result.u.var).var.ptr_ptr);
+			PZVAL_UNLOCK_FREE(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
 		}
 	} else {
 		zend_free_op free_res;
@@ -2275,7 +2275,7 @@
 
 ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval **param, *assignment_value;
 	zend_uint arg_num = opline->op1.u.constant.value.lval;
 	zend_free_op free_res;
@@ -2318,12 +2318,12 @@
 
 ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 
 	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
-	EX_T(opline->result.u.var).tmp_var.value.lval = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	EX_T_OPLINE(result.u.var).tmp_var.value.lval = i_zend_is_true(GET_OP1_ZVAL_PTR(BP_VAR_R));
+	EX_T_OPLINE(result.u.var).tmp_var.type = IS_BOOL;
 	FREE_OP1();
 
 	ZEND_VM_NEXT_OPCODE();
@@ -2331,7 +2331,7 @@
 
 ZEND_VM_HANDLER(50, ZEND_BRK, ANY, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op2;
 	zend_brk_cont_element *el;
 
@@ -2343,7 +2343,7 @@
 
 ZEND_VM_HANDLER(51, ZEND_CONT, ANY, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op2;
 	zend_brk_cont_element *el;
 
@@ -2355,19 +2355,19 @@
 
 ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	int switch_expr_is_overloaded=0;
 	zend_free_op free_op1, free_op2;
 
 	if (OP1_TYPE==IS_VAR) {
-		if (EX_T(opline->op1.u.var).var.ptr_ptr) {
-			PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
+		if (EX_T_OPLINE(op1.u.var).var.ptr_ptr) {
+			PZVAL_LOCK(EX_T_OPLINE(op1.u.var).var.ptr);
 		} else {
 			switch_expr_is_overloaded = 1;
-			EX_T(opline->op1.u.var).str_offset.str->refcount++;
+			EX_T_OPLINE(op1.u.var).str_offset.str->refcount++;
 		}
 	}
-	is_equal_function(&EX_T(opline->result.u.var).tmp_var,
+	is_equal_function(&EX_T_OPLINE(result.u.var).tmp_var,
 				 GET_OP1_ZVAL_PTR(BP_VAR_R),
 				 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 
@@ -2379,8 +2379,8 @@
 		 * are allocated at each get_zval_ptr())
 		 */
 		FREE_OP1();
-		EX_T(opline->op1.u.var).var.ptr_ptr = NULL;
-		AI_USE_PTR(EX_T(opline->op1.u.var).var);
+		EX_T_OPLINE(op1.u.var).var.ptr_ptr = NULL;
+		AI_USE_PTR(EX_T_OPLINE(op1.u.var).var);
 	}
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -2393,38 +2393,38 @@
 
 ZEND_VM_HANDLER(68, ZEND_NEW, ANY, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval *object_zval;
 	zend_function *constructor;
 
-	if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
+	if (EX_T_OPLINE(op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
 		char *class_type;
 
-		if (EX_T(opline->op1.u.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
+		if (EX_T_OPLINE(op1.u.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
 			class_type = "interface";
 		} else {
 			class_type = "abstract class";
 		}
-		zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type,  EX_T(opline->op1.u.var).class_entry->name);
+		zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type,  EX_T_OPLINE(op1.u.var).class_entry->name);
 	}
 	ALLOC_ZVAL(object_zval);
-	object_init_ex(object_zval, EX_T(opline->op1.u.var).class_entry);
+	object_init_ex(object_zval, EX_T_OPLINE(op1.u.var).class_entry);
 	INIT_PZVAL(object_zval);
 
 	constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
 
 	if (constructor == NULL) {
 		if (RETURN_VALUE_USED(opline)) {
-			EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
-			EX_T(opline->result.u.var).var.ptr = object_zval;
+			EX_T_OPLINE(result.u.var).var.ptr_ptr = &EX_T_OPLINE(result.u.var).var.ptr;
+			EX_T_OPLINE(result.u.var).var.ptr = object_zval;
 		} else {
 			zval_ptr_dtor(&object_zval);
 		}
 		ZEND_VM_JMP(EX(op_array)->opcodes + opline->op2.u.opline_num);
 	} else {
 		SELECTIVE_PZVAL_LOCK(object_zval, &opline->result);
-		EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
-		EX_T(opline->result.u.var).var.ptr = object_zval;
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = &EX_T_OPLINE(result.u.var).var.ptr;
+		EX_T_OPLINE(result.u.var).var.ptr = object_zval;
 		
 		zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), opline);
 
@@ -2438,7 +2438,7 @@
 
 ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *obj = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
 	zend_class_entry *ce;
@@ -2447,8 +2447,8 @@
 
 	if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
 		zend_error(E_WARNING, "__clone method called on non-object");
-		EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
-		EX_T(opline->result.u.var).var.ptr->refcount++;
+		EX_T_OPLINE(result.u.var).var.ptr = EG(error_zval_ptr);
+		EX_T_OPLINE(result.u.var).var.ptr->refcount++;
 		FREE_OP1_IF_VAR();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -2458,8 +2458,8 @@
 	clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
 	if (!clone_call) {
 		zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
-		EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
-		EX_T(opline->result.u.var).var.ptr->refcount++;
+		EX_T_OPLINE(result.u.var).var.ptr = EG(error_zval_ptr);
+		EX_T_OPLINE(result.u.var).var.ptr->refcount++;
 	}
 
 	if (ce && clone) {
@@ -2478,15 +2478,15 @@
 		}
 	}
 
-	EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
-	ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
-	EX_T(opline->result.u.var).var.ptr->value.obj = clone_call(obj TSRMLS_CC);
+	EX_T_OPLINE(result.u.var).var.ptr_ptr = &EX_T_OPLINE(result.u.var).var.ptr;
+	ALLOC_ZVAL(EX_T_OPLINE(result.u.var).var.ptr);
+	EX_T_OPLINE(result.u.var).var.ptr->value.obj = clone_call(obj TSRMLS_CC);
 	if (EG(exception)) {
-		FREE_ZVAL(EX_T(opline->result.u.var).var.ptr);
+		FREE_ZVAL(EX_T_OPLINE(result.u.var).var.ptr);
 	} else {
-		EX_T(opline->result.u.var).var.ptr->type = IS_OBJECT;
-		EX_T(opline->result.u.var).var.ptr->refcount=1;
-		EX_T(opline->result.u.var).var.ptr->is_ref=1;
+		EX_T_OPLINE(result.u.var).var.ptr->type = IS_OBJECT;
+		EX_T_OPLINE(result.u.var).var.ptr->refcount=1;
+		EX_T_OPLINE(result.u.var).var.ptr->is_ref=1;
 	}
 	FREE_OP1_IF_VAR();
 	ZEND_VM_NEXT_OPCODE();
@@ -2494,7 +2494,7 @@
 
 ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, CONST|UNUSED, CONST)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_class_entry *ce = NULL;
 	zval **value;
 
@@ -2504,28 +2504,28 @@
 			ce = EG(scope);
 			if (zend_hash_find(&ce->constants_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, (void **) &value) == SUCCESS) {
 				zval_update_constant(value, (void *) 1 TSRMLS_CC);
-				EX_T(opline->result.u.var).tmp_var = **value;
-				zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
+				EX_T_OPLINE(result.u.var).tmp_var = **value;
+				zval_copy_ctor(&EX_T_OPLINE(result.u.var).tmp_var);
 				ZEND_VM_NEXT_OPCODE();
 			}
 		}
 */
-		if (!zend_get_constant(opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len, &EX_T(opline->result.u.var).tmp_var TSRMLS_CC)) {
+		if (!zend_get_constant(opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len, &EX_T_OPLINE(result.u.var).tmp_var TSRMLS_CC)) {
 			zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
 						opline->op2.u.constant.value.str.val,
 						opline->op2.u.constant.value.str.val);
-			EX_T(opline->result.u.var).tmp_var = opline->op2.u.constant;
-			zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
+			EX_T_OPLINE(result.u.var).tmp_var = opline->op2.u.constant;
+			zval_copy_ctor(&EX_T_OPLINE(result.u.var).tmp_var);
 		}
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	ce = EX_T(opline->op1.u.var).class_entry;
+	ce = EX_T_OPLINE(op1.u.var).class_entry;
 
 	if (zend_hash_find(&ce->constants_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, (void **) &value) == SUCCESS) {
 		zval_update_constant(value, (void *) 1 TSRMLS_CC);
-		EX_T(opline->result.u.var).tmp_var = **value;
-		zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
+		EX_T_OPLINE(result.u.var).tmp_var = **value;
+		zval_copy_ctor(&EX_T_OPLINE(result.u.var).tmp_var);
 	} else {
 		zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", opline->op2.u.constant.value.str.val);
 	}
@@ -2535,9 +2535,9 @@
 
 ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
-	zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
+	zval *array_ptr = &EX_T_OPLINE(result.u.var).tmp_var;
 	zval *expr_ptr, **expr_ptr_ptr = NULL;
 	zval *offset=GET_OP2_ZVAL_PTR(BP_VAR_R);
 
@@ -2616,10 +2616,10 @@
 
 ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
-	zval *result = &EX_T(opline->result.u.var).tmp_var;
+	zval *result = &EX_T_OPLINE(result.u.var).tmp_var;
 
 	*result = *expr;
 	if (!IS_OP1_TMP_FREE()) {
@@ -2662,7 +2662,7 @@
 
 ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_op_array *new_op_array=NULL;
 	zval **original_return_value = EG(return_value_ptr_ptr);
 	int return_value_used;
@@ -2725,14 +2725,14 @@
 	if (inc_filename==&tmp_inc_filename) {
 		zval_dtor(&tmp_inc_filename);
 	}
-	EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+	EX_T_OPLINE(result.u.var).var.ptr_ptr = &EX_T_OPLINE(result.u.var).var.ptr;
 	if (new_op_array) {
 		zval *saved_object;
 		zend_function *saved_function;
 
-		EG(return_value_ptr_ptr) = EX_T(opline->result.u.var).var.ptr_ptr;
+		EG(return_value_ptr_ptr) = EX_T_OPLINE(result.u.var).var.ptr_ptr;
 		EG(active_op_array) = new_op_array;
-		EX_T(opline->result.u.var).var.ptr = NULL;
+		EX_T_OPLINE(result.u.var).var.ptr = NULL;
 
 		saved_object = EX(object);
 		saved_function = EX(function_state).function;
@@ -2746,15 +2746,15 @@
 		EX(object) = saved_object;
 
 		if (!return_value_used) {
-			if (EX_T(opline->result.u.var).var.ptr) {
-				zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
+			if (EX_T_OPLINE(result.u.var).var.ptr) {
+				zval_ptr_dtor(&EX_T_OPLINE(result.u.var).var.ptr);
 			}
 		} else { /* return value is used */
-			if (!EX_T(opline->result.u.var).var.ptr) { /* there was no return statement */
-				ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
-				INIT_PZVAL(EX_T(opline->result.u.var).var.ptr);
-				EX_T(opline->result.u.var).var.ptr->value.lval = 1;
-				EX_T(opline->result.u.var).var.ptr->type = IS_BOOL;
+			if (!EX_T_OPLINE(result.u.var).var.ptr) { /* there was no return statement */
+				ALLOC_ZVAL(EX_T_OPLINE(result.u.var).var.ptr);
+				INIT_PZVAL(EX_T_OPLINE(result.u.var).var.ptr);
+				EX_T_OPLINE(result.u.var).var.ptr->value.lval = 1;
+				EX_T_OPLINE(result.u.var).var.ptr->type = IS_BOOL;
 			}
 		}
 
@@ -2768,10 +2768,10 @@
 		}
 	} else {
 		if (return_value_used) {
-			ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
-			INIT_ZVAL(*EX_T(opline->result.u.var).var.ptr);
-			EX_T(opline->result.u.var).var.ptr->value.lval = failure_retval;
-			EX_T(opline->result.u.var).var.ptr->type = IS_BOOL;
+			ALLOC_ZVAL(EX_T_OPLINE(result.u.var).var.ptr);
+			INIT_ZVAL(*EX_T_OPLINE(result.u.var).var.ptr);
+			EX_T_OPLINE(result.u.var).var.ptr->value.lval = failure_retval;
+			EX_T_OPLINE(result.u.var).var.ptr->type = IS_BOOL;
 		}
 	}
 	FREE_OP1();
@@ -2781,7 +2781,7 @@
 
 ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 	zend_free_op free_op1;
@@ -2796,7 +2796,7 @@
 	}
 
 	if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
-		zend_std_unset_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
+		zend_std_unset_static_property(EX_T_OPLINE(op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname) TSRMLS_CC);
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline, EX(Ts), BP_VAR_IS, varname TSRMLS_CC);		
 		if (zend_hash_del(target_symbol_table, varname->value.str.val, varname->value.str.len+1) == SUCCESS) {		
@@ -2830,7 +2830,7 @@
 
 ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
 	zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
@@ -2920,7 +2920,7 @@
 
 ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1, free_op2;
 	zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
 	zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
@@ -2952,7 +2952,7 @@
 
 ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *array_ptr, **array_ptr_ptr;
 	HashTable *fe_ht;
@@ -3016,8 +3016,8 @@
 	}
 
 	PZVAL_LOCK(array_ptr);
-	EX_T(opline->result.u.var).var.ptr = array_ptr;
-	EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+	EX_T_OPLINE(result.u.var).var.ptr = array_ptr;
+	EX_T_OPLINE(result.u.var).var.ptr_ptr = &EX_T_OPLINE(result.u.var).var.ptr;
 
 	if (iter) {
 		iter->index = 0;
@@ -3070,7 +3070,7 @@
 
 ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *array = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	zval **value;
@@ -3176,12 +3176,12 @@
 	if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
 		SEPARATE_ZVAL_IF_NOT_REF(value);
 		(*value)->is_ref = 1;
-		EX_T(opline->result.u.var).var.ptr_ptr = value;
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = value;
 		(*value)->refcount++;
 	} else {
-		EX_T(opline->result.u.var).var.ptr_ptr = value;
-		PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
-		AI_USE_PTR(EX_T(opline->result.u.var).var);
+		EX_T_OPLINE(result.u.var).var.ptr_ptr = value;
+		PZVAL_LOCK(*EX_T_OPLINE(result.u.var).var.ptr_ptr);
+		AI_USE_PTR(EX_T_OPLINE(result.u.var).var);
 	}
 
 	if (use_key) {
@@ -3208,7 +3208,7 @@
 
 ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
 	zval **value;
@@ -3223,7 +3223,7 @@
 	}
 
 	if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
-		value = zend_std_get_static_property(EX_T(opline->op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1 TSRMLS_CC);
+		value = zend_std_get_static_property(EX_T_OPLINE(op2.u.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1 TSRMLS_CC);
 		if (!value) {
 			isset = 0;
 		}
@@ -3234,21 +3234,21 @@
 		}
 	}
 
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	EX_T_OPLINE(result.u.var).tmp_var.type = IS_BOOL;
 
 	switch (opline->extended_value) {
 		case ZEND_ISSET:
 			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				EX_T(opline->result.u.var).tmp_var.value.lval = 0;
+				EX_T_OPLINE(result.u.var).tmp_var.value.lval = 0;
 			} else {
-				EX_T(opline->result.u.var).tmp_var.value.lval = isset;
+				EX_T_OPLINE(result.u.var).tmp_var.value.lval = isset;
 			}
 			break;
 		case ZEND_ISEMPTY:
 			if (!isset || !i_zend_is_true(*value)) {
-				EX_T(opline->result.u.var).tmp_var.value.lval = 1;
+				EX_T_OPLINE(result.u.var).tmp_var.value.lval = 1;
 			} else {
-				EX_T(opline->result.u.var).tmp_var.value.lval = 0;
+				EX_T_OPLINE(result.u.var).tmp_var.value.lval = 0;
 			}
 			break;
 	}
@@ -3263,7 +3263,7 @@
 
 ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|TMP|VAR|CV, int prop_dim)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_IS);
 	zval **value = NULL;
@@ -3370,14 +3370,14 @@
 		}
 	}
 
-	EX_T(opline->result.u.var).tmp_var.type = IS_BOOL;
+	EX_T_OPLINE(result.u.var).tmp_var.type = IS_BOOL;
 
 	switch (opline->extended_value) {
 		case ZEND_ISSET:
-			EX_T(opline->result.u.var).tmp_var.value.lval = result;
+			EX_T_OPLINE(result.u.var).tmp_var.value.lval = result;
 			break;
 		case ZEND_ISEMPTY:
-			EX_T(opline->result.u.var).tmp_var.value.lval = !result;
+			EX_T_OPLINE(result.u.var).tmp_var.value.lval = !result;
 			break;
 	}
 
@@ -3399,7 +3399,7 @@
 ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY)
 {
 	if (OP1_TYPE != IS_UNUSED) {
-		zend_op *opline = EX(opline);
+		ZEND_LOAD_CONTEXT();
 		zend_free_op free_op1;
 		zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
@@ -3416,12 +3416,12 @@
 
 ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	
-	EX_T(opline->result.u.var).tmp_var.value.lval = EG(error_reporting);
-	EX_T(opline->result.u.var).tmp_var.type = IS_LONG;  /* shouldn't be necessary */
+	EX_T_OPLINE(result.u.var).tmp_var.value.lval = EG(error_reporting);
+	EX_T_OPLINE(result.u.var).tmp_var.type = IS_LONG;  /* shouldn't be necessary */
 	if (EX(old_error_reporting) == NULL) {
-		EX(old_error_reporting) = &EX_T(opline->result.u.var).tmp_var;
+		EX(old_error_reporting) = &EX_T_OPLINE(result.u.var).tmp_var;
 	}
 	
 	if (EG(error_reporting)) {
@@ -3438,17 +3438,17 @@
 
 ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zval restored_error_reporting;
 
-	if (!EG(error_reporting) && EX_T(opline->op1.u.var).tmp_var.value.lval != 0) {
+	if (!EG(error_reporting) && EX_T_OPLINE(op1.u.var).tmp_var.value.lval != 0) {
 		restored_error_reporting.type = IS_LONG;
-		restored_error_reporting.value.lval = EX_T(opline->op1.u.var).tmp_var.value.lval;
+		restored_error_reporting.value.lval = EX_T_OPLINE(op1.u.var).tmp_var.value.lval;
 		convert_to_string(&restored_error_reporting);
 		zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
 		zendi_zval_dtor(restored_error_reporting);
 	}
-	if (EX(old_error_reporting) == &EX_T(opline->op1.u.var).tmp_var) {
+	if (EX(old_error_reporting) == &EX_T_OPLINE(op1.u.var).tmp_var) {
 		EX(old_error_reporting) = NULL;
 	}
 	ZEND_VM_NEXT_OPCODE();
@@ -3456,13 +3456,13 @@
 
 ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	EX_T(opline->result.u.var).tmp_var = *value;
+	EX_T_OPLINE(result.u.var).tmp_var = *value;
 	if (!IS_OP1_TMP_FREE()) {
-		zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
+		zval_copy_ctor(&EX_T_OPLINE(result.u.var).tmp_var);
 	}
 	FREE_OP1_IF_VAR();
 	ZEND_VM_NEXT_OPCODE();
@@ -3494,17 +3494,17 @@
 
 ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, ANY, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 
-	EX_T(opline->result.u.var).class_entry = do_bind_class(opline, EG(class_table), 0 TSRMLS_CC);
+	EX_T_OPLINE(result.u.var).class_entry = do_bind_class(opline, EG(class_table), 0 TSRMLS_CC);
 	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 
-	EX_T(opline->result.u.var).class_entry = do_bind_inherited_class(opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
+	EX_T_OPLINE(result.u.var).class_entry = do_bind_inherited_class(opline, EG(class_table), EX_T_OPLINE(extended_value).class_entry, 0 TSRMLS_CC);
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -3516,7 +3516,7 @@
 
 ZEND_VM_HANDLER(105, ZEND_TICKS, CONST, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 
 	if (++EG(ticks_count)>=opline->op1.u.constant.value.lval) {
 		EG(ticks_count)=0;
@@ -3529,17 +3529,17 @@
 
 ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMP|VAR|CV, ANY)
 {
-	zend_op *opline = EX(opline);
+	ZEND_LOAD_CONTEXT();
 	zend_free_op free_op1;
 	zval *expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	zend_bool result;
 
 	if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
-		result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.u.var).class_entry TSRMLS_CC);
+		result = instanceof_function(Z_OBJCE_P(expr), EX_T_OPLINE(op2.u.var).class_entry TSRMLS_CC);
 	} else {
 		result = 0;
 	}
-	ZVAL_BOOL(&EX_T(opline->result.u.var).tmp_var, result);
+	ZVAL_BOOL(&EX_T_OPLINE(result.u.var).tmp_var, result);
 	FREE_OP1();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -3556,9 +3556,9 @@
 
 ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, ANY)
 {
-	zend_op *opline = EX(opline);
-	zend_class_entry *ce = EX_T(opline->op1.u.var).class_entry;
-	zend_class_entry *iface = EX_T(opline->op2.u.var).class_entry;
+	ZEND_LOAD_CONTEXT();
+	zend_class_entry *ce = EX_T_OPLINE(op1.u.var).class_entry;
+	zend_class_entry *iface = EX_T_OPLINE(op2.u.var).class_entry;
 
 	if (!(iface->ce_flags & ZEND_ACC_INTERFACE)) {
 		zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);