Consolidate op1/op2 vm flags

3 files changed, 89 insertions, 109 deletions

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 5899199c1f..ab7961027c 100644
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -55,31 +55,18 @@ define("ZEND_VM_KIND_SWITCH", 2);
 define("ZEND_VM_KIND_GOTO",   3);
 
 $vm_op_flags = array(
-	"ZEND_VM_OP1_SPEC"        => 1<<0,
-	"ZEND_VM_OP1_CONST"       => 1<<1,
-	"ZEND_VM_OP1_TMPVAR"      => 1<<2,
-	"ZEND_VM_OP1_MASK"        => 0xf0,
-	"ZEND_VM_OP1_NUM"         => 0x10,
-	"ZEND_VM_OP1_JMP_ADDR"    => 0x20,
-	"ZEND_VM_OP1_TRY_CATCH"   => 0x30,
-	"ZEND_VM_OP1_LIVE_RANGE"  => 0x40,
-	"ZEND_VM_OP1_THIS"        => 0x50,
-	"ZEND_VM_OP1_NEXT"        => 0x60,
-	"ZEND_VM_OP1_CLASS_FETCH" => 0x70,
-	"ZEND_VM_OP1_CONSTRUCTOR" => 0x80,
-
-	"ZEND_VM_OP2_SPEC"        => 1<<8,
-	"ZEND_VM_OP2_CONST"       => 1<<9,
-	"ZEND_VM_OP2_TMPVAR"      => 1<<10,
-	"ZEND_VM_OP2_MASK"        => 0xf000,
-	"ZEND_VM_OP2_NUM"         => 0x1000,
-	"ZEND_VM_OP2_JMP_ADDR"    => 0x2000,
-	"ZEND_VM_OP2_TRY_CATCH"   => 0x3000,
-	"ZEND_VM_OP2_LIVE_RANGE"  => 0x4000,
-	"ZEND_VM_OP2_THIS"        => 0x5000,
-	"ZEND_VM_OP2_NEXT"        => 0x6000,
-	"ZEND_VM_OP2_CLASS_FETCH" => 0x7000,
-	"ZEND_VM_OP2_CONSTRUCTOR" => 0x8000,
+	"ZEND_VM_OP_SPEC"         => 1<<0,
+	"ZEND_VM_OP_CONST"        => 1<<1,
+	"ZEND_VM_OP_TMPVAR"       => 1<<2,
+	"ZEND_VM_OP_MASK"         => 0xf0,
+	"ZEND_VM_OP_NUM"          => 0x10,
+	"ZEND_VM_OP_JMP_ADDR"     => 0x20,
+	"ZEND_VM_OP_TRY_CATCH"    => 0x30,
+	"ZEND_VM_OP_LIVE_RANGE"   => 0x40,
+	"ZEND_VM_OP_THIS"         => 0x50,
+	"ZEND_VM_OP_NEXT"         => 0x60,
+	"ZEND_VM_OP_CLASS_FETCH"  => 0x70,
+	"ZEND_VM_OP_CONSTRUCTOR"  => 0x80,
 
 	"ZEND_VM_EXT_VAR_FETCH"   => 1<<16,
 	"ZEND_VM_EXT_ISSET"       => 1<<17,
@@ -107,20 +94,20 @@ foreach ($vm_op_flags as $name => $val) {
 
 $vm_op_decode = array(
 	"ANY"                  => 0,
-	"CONST"                => ZEND_VM_OP1_SPEC | ZEND_VM_OP1_CONST,
-	"TMP"                  => ZEND_VM_OP1_SPEC,
-	"VAR"                  => ZEND_VM_OP1_SPEC,
-	"UNUSED"               => ZEND_VM_OP1_SPEC,
-	"CV"                   => ZEND_VM_OP1_SPEC,
-	"TMPVAR"               => ZEND_VM_OP1_SPEC | ZEND_VM_OP1_TMPVAR,
-	"NUM"                  => ZEND_VM_OP1_NUM,
-	"JMP_ADDR"             => ZEND_VM_OP1_JMP_ADDR,
-	"TRY_CATCH"            => ZEND_VM_OP1_TRY_CATCH,
-	"LIVE_RANGE"           => ZEND_VM_OP1_LIVE_RANGE,
-	"THIS"                 => ZEND_VM_OP1_THIS,
-	"NEXT"                 => ZEND_VM_OP1_NEXT,
-	"CLASS_FETCH"          => ZEND_VM_OP1_CLASS_FETCH,
-	"CONSTRUCTOR"          => ZEND_VM_OP1_CONSTRUCTOR,
+	"CONST"                => ZEND_VM_OP_SPEC | ZEND_VM_OP_CONST,
+	"TMP"                  => ZEND_VM_OP_SPEC,
+	"VAR"                  => ZEND_VM_OP_SPEC,
+	"UNUSED"               => ZEND_VM_OP_SPEC,
+	"CV"                   => ZEND_VM_OP_SPEC,
+	"TMPVAR"               => ZEND_VM_OP_SPEC | ZEND_VM_OP_TMPVAR,
+	"NUM"                  => ZEND_VM_OP_NUM,
+	"JMP_ADDR"             => ZEND_VM_OP_JMP_ADDR,
+	"TRY_CATCH"            => ZEND_VM_OP_TRY_CATCH,
+	"LIVE_RANGE"           => ZEND_VM_OP_LIVE_RANGE,
+	"THIS"                 => ZEND_VM_OP_THIS,
+	"NEXT"                 => ZEND_VM_OP_NEXT,
+	"CLASS_FETCH"          => ZEND_VM_OP_CLASS_FETCH,
+	"CONSTRUCTOR"          => ZEND_VM_OP_CONSTRUCTOR,
 );
 
 $vm_ext_decode = array(
@@ -1445,7 +1432,7 @@ function parse_operand_spec($def, $lineno, $str, &$flags) {
 			die("ERROR ($def:$lineno): Wrong operand type '$str'\n");
 		}
 	}
-	if (!($flags & ZEND_VM_OP1_SPEC)) {
+	if (!($flags & ZEND_VM_OP_SPEC)) {
 		if (count($a) != 1) {
 			die("ERROR ($def:$lineno): Wrong operand type '$str'\n");
 		}
@@ -1649,6 +1636,8 @@ function gen_vm($def, $skel) {
 	foreach($vm_op_flags as $name => $val) {
 		fprintf($f, "#define %-24s 0x%08x\n", $name, $val);
 	}
+	fputs($f, "#define ZEND_VM_OP1_FLAGS(flags) (flags & 0xff)\n");
+	fputs($f, "#define ZEND_VM_OP2_FLAGS(flags) ((flags >> 8) & 0xff)\n");
 	fputs($f, "\n");
 	fputs($f, "BEGIN_EXTERN_C()\n\n");
 	fputs($f, "ZEND_API const char *zend_get_opcode_name(zend_uchar opcode);\n");
diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 1b23b76516..768dbb87c8 100644
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -28,30 +28,18 @@
 #define ZEND_VM_KIND_GOTO	3
 #define ZEND_VM_KIND		ZEND_VM_KIND_CALL
 
-#define ZEND_VM_OP1_SPEC         0x00000001
-#define ZEND_VM_OP1_CONST        0x00000002
-#define ZEND_VM_OP1_TMPVAR       0x00000004
-#define ZEND_VM_OP1_MASK         0x000000f0
-#define ZEND_VM_OP1_NUM          0x00000010
-#define ZEND_VM_OP1_JMP_ADDR     0x00000020
-#define ZEND_VM_OP1_TRY_CATCH    0x00000030
-#define ZEND_VM_OP1_LIVE_RANGE   0x00000040
-#define ZEND_VM_OP1_THIS         0x00000050
-#define ZEND_VM_OP1_NEXT         0x00000060
-#define ZEND_VM_OP1_CLASS_FETCH  0x00000070
-#define ZEND_VM_OP1_CONSTRUCTOR  0x00000080
-#define ZEND_VM_OP2_SPEC         0x00000100
-#define ZEND_VM_OP2_CONST        0x00000200
-#define ZEND_VM_OP2_TMPVAR       0x00000400
-#define ZEND_VM_OP2_MASK         0x0000f000
-#define ZEND_VM_OP2_NUM          0x00001000
-#define ZEND_VM_OP2_JMP_ADDR     0x00002000
-#define ZEND_VM_OP2_TRY_CATCH    0x00003000
-#define ZEND_VM_OP2_LIVE_RANGE   0x00004000
-#define ZEND_VM_OP2_THIS         0x00005000
-#define ZEND_VM_OP2_NEXT         0x00006000
-#define ZEND_VM_OP2_CLASS_FETCH  0x00007000
-#define ZEND_VM_OP2_CONSTRUCTOR  0x00008000
+#define ZEND_VM_OP_SPEC          0x00000001
+#define ZEND_VM_OP_CONST         0x00000002
+#define ZEND_VM_OP_TMPVAR        0x00000004
+#define ZEND_VM_OP_MASK          0x000000f0
+#define ZEND_VM_OP_NUM           0x00000010
+#define ZEND_VM_OP_JMP_ADDR      0x00000020
+#define ZEND_VM_OP_TRY_CATCH     0x00000030
+#define ZEND_VM_OP_LIVE_RANGE    0x00000040
+#define ZEND_VM_OP_THIS          0x00000050
+#define ZEND_VM_OP_NEXT          0x00000060
+#define ZEND_VM_OP_CLASS_FETCH   0x00000070
+#define ZEND_VM_OP_CONSTRUCTOR   0x00000080
 #define ZEND_VM_EXT_VAR_FETCH    0x00010000
 #define ZEND_VM_EXT_ISSET        0x00020000
 #define ZEND_VM_EXT_ARG_NUM      0x00040000
@@ -69,6 +57,8 @@
 #define ZEND_VM_EXT_FAST_RET     0x0a000000
 #define ZEND_VM_EXT_SRC          0x0b000000
 #define ZEND_VM_EXT_SEND         0x0c000000
+#define ZEND_VM_OP1_FLAGS(flags) (flags & 0xff)
+#define ZEND_VM_OP2_FLAGS(flags) ((flags >> 8) & 0xff)
 
 BEGIN_EXTERN_C()
 
diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index 46952c1159..295bf3f90a 100644
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -88,6 +88,26 @@ static void zend_dump_class_fetch_type(uint32_t fetch_type)
 	}
 }
 
+static void zend_dump_unused_op(const zend_op *opline, znode_op op, uint32_t flags) {
+	if (ZEND_VM_OP_NUM == (flags & ZEND_VM_OP_MASK)) {
+		fprintf(stderr, " %u", op.num);
+	} else if (ZEND_VM_OP_TRY_CATCH == (flags & ZEND_VM_OP_MASK)) {
+		fprintf(stderr, " try-catch(%u)", op.num);
+	} else if (ZEND_VM_OP_LIVE_RANGE == (flags & ZEND_VM_OP_MASK)) {
+		if (opline->extended_value & ZEND_FREE_ON_RETURN) {
+			fprintf(stderr, " live-range(%u)", op.num);
+		}
+	} else if (ZEND_VM_OP_THIS == (flags & ZEND_VM_OP_MASK)) {
+		fprintf(stderr, " THIS");
+	} else if (ZEND_VM_OP_NEXT == (flags & ZEND_VM_OP_MASK)) {
+		fprintf(stderr, " NEXT");
+	} else if (ZEND_VM_OP_CLASS_FETCH == (flags & ZEND_VM_OP_MASK)) {
+		zend_dump_class_fetch_type(op.num);
+	} else if (ZEND_VM_OP_CONSTRUCTOR == (flags & ZEND_VM_OP_MASK)) {
+		fprintf(stderr, " CONSTRUCTOR");
+	}
+}
+
 void zend_dump_var(const zend_op_array *op_array, zend_uchar var_type, int var_num)
 {
 	if (var_type == IS_CV && var_num < op_array->last_var) {
@@ -546,21 +566,8 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
 			}
 		}
 	}
-	if (ZEND_VM_OP1_JMP_ADDR == (flags & ZEND_VM_OP1_MASK)) {
-		if (b) {
-			fprintf(stderr, " BB%d", b->successors[n++]);
-		} else {
-			fprintf(stderr, " L%u", (uint32_t)(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes));
-		}
-	} else if (ZEND_VM_OP1_NUM == (flags & ZEND_VM_OP1_MASK)) {
-		fprintf(stderr, " %u", opline->op1.num);
-	} else if (ZEND_VM_OP1_TRY_CATCH == (flags & ZEND_VM_OP1_MASK)) {
-		fprintf(stderr, " try-catch(%u)", opline->op1.num);
-	} else if (ZEND_VM_OP1_LIVE_RANGE == (flags & ZEND_VM_OP1_MASK)) {
-		if (opline->extended_value & ZEND_FREE_ON_RETURN) {
-			fprintf(stderr, " live-range(%u)", opline->op1.num);
-		}
-	} else if (opline->op1_type == IS_CONST) {
+
+	if (opline->op1_type == IS_CONST) {
 		zend_dump_const(CRT_CONSTANT_EX(op_array, opline->op1, (dump_flags & ZEND_DUMP_RT_CONSTANTS)));
 	} else if (opline->op1_type == IS_CV ||
 	           opline->op1_type == IS_VAR ||
@@ -585,30 +592,20 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
 				zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->op1_type, EX_VAR_TO_NUM(opline->op1.var));
 			}
 		}
-	} else if (ZEND_VM_OP1_THIS == (flags & ZEND_VM_OP1_MASK)) {
-		fprintf(stderr, " THIS");
-	} else if (ZEND_VM_OP1_NEXT == (flags & ZEND_VM_OP1_MASK)) {
-		fprintf(stderr, " NEXT");
-	} else if (ZEND_VM_OP1_CLASS_FETCH == (flags & ZEND_VM_OP1_MASK)) {
-		zend_dump_class_fetch_type(opline->op1.num);
-	} else if (ZEND_VM_OP1_CONSTRUCTOR == (flags & ZEND_VM_OP1_MASK)) {
-		fprintf(stderr, " CONSTRUCTOR");
-	}
-	if (ZEND_VM_OP2_JMP_ADDR == (flags & ZEND_VM_OP2_MASK)) {
-		if (b) {
-			fprintf(stderr, " BB%d", b->successors[n++]);
+	} else {
+		uint32_t op1_flags = ZEND_VM_OP1_FLAGS(flags);
+		if (ZEND_VM_OP_JMP_ADDR == (op1_flags & ZEND_VM_OP_MASK)) {
+			if (b) {
+				fprintf(stderr, " BB%d", b->successors[n++]);
+			} else {
+				fprintf(stderr, " L%u", (uint32_t)(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes));
+			}
 		} else {
-			fprintf(stderr, " L%u", (uint32_t)(OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes));
-		}
-	} else if (ZEND_VM_OP2_NUM == (flags & ZEND_VM_OP2_MASK)) {
-		fprintf(stderr, " %u", opline->op2.num);
-	} else if (ZEND_VM_OP2_TRY_CATCH == (flags & ZEND_VM_OP2_MASK)) {
-		fprintf(stderr, " try-catch(%u)", opline->op2.num);
-	} else if (ZEND_VM_OP2_LIVE_RANGE == (flags & ZEND_VM_OP2_MASK)) {
-		if (opline->extended_value & ZEND_FREE_ON_RETURN) {
-			fprintf(stderr, " live-range(%u)", opline->op2.num);
+			zend_dump_unused_op(opline, opline->op1, op1_flags);
 		}
-	} else if (opline->op2_type == IS_CONST) {
+	}
+
+	if (opline->op2_type == IS_CONST) {
 		zend_dump_const(CRT_CONSTANT_EX(op_array, opline->op2, (dump_flags & ZEND_DUMP_RT_CONSTANTS)));
 	} else if (opline->op2_type == IS_CV ||
 	           opline->op2_type == IS_VAR ||
@@ -633,15 +630,19 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
 				zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->op2_type, EX_VAR_TO_NUM(opline->op2.var));
 			}
 		}
-	} else if (ZEND_VM_OP2_THIS == (flags & ZEND_VM_OP2_MASK)) {
-		fprintf(stderr, " THIS");
-	} else if (ZEND_VM_OP2_NEXT == (flags & ZEND_VM_OP2_MASK)) {
-		fprintf(stderr, " NEXT");
-	} else if (ZEND_VM_OP2_CLASS_FETCH == (flags & ZEND_VM_OP2_MASK)) {
-		zend_dump_class_fetch_type(opline->op2.num);
-	} else if (ZEND_VM_OP2_CONSTRUCTOR == (flags & ZEND_VM_OP2_MASK)) {
-		fprintf(stderr, " CONSTRUCTOR");
+	} else {
+		uint32_t op2_flags = ZEND_VM_OP2_FLAGS(flags);
+		if (ZEND_VM_OP_JMP_ADDR == (op2_flags & ZEND_VM_OP_MASK)) {
+			if (b) {
+				fprintf(stderr, " BB%d", b->successors[n++]);
+			} else {
+				fprintf(stderr, " L%u", (uint32_t)(OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes));
+			}
+		} else {
+			zend_dump_unused_op(opline, opline->op2, op2_flags);
+		}
 	}
+
 	if (ZEND_VM_EXT_JMP_ADDR == (flags & ZEND_VM_EXT_MASK)) {
 		if (opline->opcode != ZEND_CATCH || !opline->result.num) {
 			if (b) {