Consolidate op1/op2 vm flags

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 5899199c1f3f91b544a29b080dbd1cea25db1a0c..ab7961027c027472d805e943fe1e69625efd47c5 100644 (file)
--- 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 1b23b765161920ea05c96c5f558c1c52d948c355..768dbb87c884ee1dc18e2c977492fabe8ab0e015 100644 (file)
--- 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 46952c1159f03b76bf37f3b1c0bfc6a8d469a728..295bf3f90aabd7ca4fdaefc044c97c6360128a80 100644 (file)
--- 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) {