Permalink
Switch branches/tags
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
3126 lines (2938 sloc) 111 KB
<?php
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
| Copyright (c) 1998-2018 Zend Technologies Ltd. (http://www.zend.com) |
+----------------------------------------------------------------------+
| This source file is subject to version 2.00 of the Zend license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.zend.com/license/2_00.txt. |
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@zend.com so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Dmitry Stogov <dmitry@zend.com> |
+----------------------------------------------------------------------+
*/
const HEADER_TEXT = <<< DATA
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
| Copyright (c) 1998-2018 Zend Technologies Ltd. (http://www.zend.com) |
+----------------------------------------------------------------------+
| This source file is subject to version 2.00 of the Zend license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.zend.com/license/2_00.txt. |
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@zend.com so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Andi Gutmans <andi@zend.com> |
| Zeev Suraski <zeev@zend.com> |
| Dmitry Stogov <dmitry@zend.com> |
+----------------------------------------------------------------------+
*/
DATA;
/*
This script creates zend_vm_execute.h and zend_vm_opcodes.h
from existing zend_vm_def.h and zend_vm_execute.skl
*/
error_reporting(E_ALL);
const ZEND_VM_KIND_CALL = 1;
const ZEND_VM_KIND_SWITCH = 2;
const ZEND_VM_KIND_GOTO = 3;
const ZEND_VM_KIND_HYBRID = 4;
$vm_op_flags = array(
"ZEND_VM_OP_SPEC" => 1<<0,
"ZEND_VM_OP_CONST" => 1<<1,
"ZEND_VM_OP_TMPVAR" => 1<<2,
"ZEND_VM_OP_TMPVARCV" => 1<<3,
"ZEND_VM_OP_MASK" => 0xf0,
"ZEND_VM_OP_NUM" => 0x10,
"ZEND_VM_OP_JMP_ADDR" => 0x20,
"ZEND_VM_OP_TRY_CATCH" => 0x30,
// unused 0x40
"ZEND_VM_OP_THIS" => 0x50,
"ZEND_VM_OP_NEXT" => 0x60,
"ZEND_VM_OP_CLASS_FETCH" => 0x70,
"ZEND_VM_OP_CONSTRUCTOR" => 0x80,
"ZEND_VM_OP_CONST_FETCH" => 0x90,
"ZEND_VM_OP_CACHE_SLOT" => 0xa0,
"ZEND_VM_EXT_VAR_FETCH" => 1<<16,
"ZEND_VM_EXT_ISSET" => 1<<17,
"ZEND_VM_EXT_CACHE_SLOT" => 1<<18,
"ZEND_VM_EXT_ARRAY_INIT" => 1<<19,
"ZEND_VM_EXT_REF" => 1<<20,
"ZEND_VM_EXT_MASK" => 0x0f000000,
"ZEND_VM_EXT_NUM" => 0x01000000,
"ZEND_VM_EXT_LAST_CATCH" => 0x02000000,
"ZEND_VM_EXT_JMP_ADDR" => 0x03000000,
"ZEND_VM_EXT_DIM_OBJ" => 0x04000000,
// unused 0x5000000
// unused 0x6000000
"ZEND_VM_EXT_TYPE" => 0x07000000,
"ZEND_VM_EXT_EVAL" => 0x08000000,
"ZEND_VM_EXT_TYPE_MASK" => 0x09000000,
// unused 0x0a000000,
"ZEND_VM_EXT_SRC" => 0x0b000000,
// unused 0x0c000000,
"ZEND_VM_NO_CONST_CONST" => 0x40000000,
"ZEND_VM_COMMUTATIVE" => 0x80000000,
);
foreach ($vm_op_flags as $name => $val) {
define($name, $val);
}
$vm_op_decode = array(
"ANY" => 0,
"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,
"TMPVARCV" => ZEND_VM_OP_SPEC | ZEND_VM_OP_TMPVARCV,
"NUM" => ZEND_VM_OP_NUM,
"JMP_ADDR" => ZEND_VM_OP_JMP_ADDR,
"TRY_CATCH" => ZEND_VM_OP_TRY_CATCH,
"THIS" => ZEND_VM_OP_THIS,
"NEXT" => ZEND_VM_OP_NEXT,
"CLASS_FETCH" => ZEND_VM_OP_CLASS_FETCH,
"CONSTRUCTOR" => ZEND_VM_OP_CONSTRUCTOR,
"CONST_FETCH" => ZEND_VM_OP_CONST_FETCH,
"CACHE_SLOT" => ZEND_VM_OP_CACHE_SLOT,
);
$vm_ext_decode = array(
"NUM" => ZEND_VM_EXT_NUM,
"LAST_CATCH" => ZEND_VM_EXT_LAST_CATCH,
"JMP_ADDR" => ZEND_VM_EXT_JMP_ADDR,
"DIM_OBJ" => ZEND_VM_EXT_DIM_OBJ,
"VAR_FETCH" => ZEND_VM_EXT_VAR_FETCH,
"ARRAY_INIT" => ZEND_VM_EXT_ARRAY_INIT,
"TYPE" => ZEND_VM_EXT_TYPE,
"EVAL" => ZEND_VM_EXT_EVAL,
"TYPE_MASK" => ZEND_VM_EXT_TYPE_MASK,
"ISSET" => ZEND_VM_EXT_ISSET,
"REF" => ZEND_VM_EXT_REF,
"SRC" => ZEND_VM_EXT_SRC,
"CACHE_SLOT" => ZEND_VM_EXT_CACHE_SLOT,
);
$vm_kind_name = array(
ZEND_VM_KIND_CALL => "ZEND_VM_KIND_CALL",
ZEND_VM_KIND_SWITCH => "ZEND_VM_KIND_SWITCH",
ZEND_VM_KIND_GOTO => "ZEND_VM_KIND_GOTO",
ZEND_VM_KIND_HYBRID => "ZEND_VM_KIND_HYBRID",
);
$op_types = array(
"ANY",
"CONST",
"TMP",
"VAR",
"UNUSED",
"CV"
);
$op_types_ex = array(
"ANY",
"CONST",
"TMPVARCV",
"TMPVAR",
"TMP",
"VAR",
"UNUSED",
"CV",
);
$prefix = array(
"ANY" => "",
"TMP" => "_TMP",
"VAR" => "_VAR",
"CONST" => "_CONST",
"UNUSED" => "_UNUSED",
"CV" => "_CV",
"TMPVAR" => "_TMPVAR",
"TMPVARCV" => "_TMPVARCV",
);
$commutative_order = array(
"ANY" => 0,
"TMP" => 1,
"VAR" => 2,
"CONST" => 0,
"UNUSED" => 0,
"CV" => 4,
"TMPVAR" => 2,
"TMPVARCV" => 4,
);
$op1_type = array(
"ANY" => "opline->op1_type",
"TMP" => "IS_TMP_VAR",
"VAR" => "IS_VAR",
"CONST" => "IS_CONST",
"UNUSED" => "IS_UNUSED",
"CV" => "IS_CV",
"TMPVAR" => "(IS_TMP_VAR|IS_VAR)",
"TMPVARCV" => "(IS_TMP_VAR|IS_VAR|IS_CV)",
);
$op2_type = array(
"ANY" => "opline->op2_type",
"TMP" => "IS_TMP_VAR",
"VAR" => "IS_VAR",
"CONST" => "IS_CONST",
"UNUSED" => "IS_UNUSED",
"CV" => "IS_CV",
"TMPVAR" => "(IS_TMP_VAR|IS_VAR)",
"TMPVARCV" => "(IS_TMP_VAR|IS_VAR|IS_CV)",
);
$op1_free = array(
"ANY" => "(free_op1 != NULL)",
"TMP" => "1",
"VAR" => "(free_op1 != NULL)",
"CONST" => "0",
"UNUSED" => "0",
"CV" => "0",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op2_free = array(
"ANY" => "(free_op2 != NULL)",
"TMP" => "1",
"VAR" => "(free_op2 != NULL)",
"CONST" => "0",
"UNUSED" => "0",
"CV" => "0",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op1_get_zval_ptr = array(
"ANY" => "get_zval_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op1)",
"UNUSED" => "NULL",
"CV" => "_get_zval_ptr_cv_\\1(opline->op1.var EXECUTE_DATA_CC)",
"TMPVAR" => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"TMPVARCV" => "???",
);
$op2_get_zval_ptr = array(
"ANY" => "get_zval_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op2)",
"UNUSED" => "NULL",
"CV" => "_get_zval_ptr_cv_\\1(opline->op2.var EXECUTE_DATA_CC)",
"TMPVAR" => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"TMPVARCV" => "???",
);
$op1_get_zval_ptr_ptr = array(
"ANY" => "get_zval_ptr_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "NULL",
"VAR" => "_get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "NULL",
"UNUSED" => "NULL",
"CV" => "_get_zval_ptr_cv_\\1(opline->op1.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op2_get_zval_ptr_ptr = array(
"ANY" => "get_zval_ptr_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "NULL",
"VAR" => "_get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "NULL",
"UNUSED" => "NULL",
"CV" => "_get_zval_ptr_cv_\\1(opline->op2.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op1_get_zval_ptr_deref = array(
"ANY" => "get_zval_ptr_deref(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op1)",
"UNUSED" => "NULL",
"CV" => "_get_zval_ptr_cv_deref_\\1(opline->op1.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op2_get_zval_ptr_deref = array(
"ANY" => "get_zval_ptr_deref(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op2)",
"UNUSED" => "NULL",
"CV" => "_get_zval_ptr_cv_deref_\\1(opline->op2.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op1_get_zval_ptr_undef = array(
"ANY" => "get_zval_ptr_undef(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op1)",
"UNUSED" => "NULL",
"CV" => "EX_VAR(opline->op1.var)",
"TMPVAR" => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"TMPVARCV" => "EX_VAR(opline->op1.var)",
);
$op2_get_zval_ptr_undef = array(
"ANY" => "get_zval_ptr_undef(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op2)",
"UNUSED" => "NULL",
"CV" => "EX_VAR(opline->op2.var)",
"TMPVAR" => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"TMPVARCV" => "EX_VAR(opline->op2.var)",
);
$op1_get_zval_ptr_ptr_undef = array(
"ANY" => "get_zval_ptr_ptr_undef(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "NULL",
"VAR" => "_get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "NULL",
"UNUSED" => "NULL",
"CV" => "EX_VAR(opline->op1.var)",
"TMPVAR" => "???",
"TMPVARCV" => "EX_VAR(opline->op1.var)",
);
$op2_get_zval_ptr_ptr_undef = array(
"ANY" => "get_zval_ptr_ptr_undef(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "NULL",
"VAR" => "_get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "NULL",
"UNUSED" => "NULL",
"CV" => "EX_VAR(opline->op2.var)",
"TMPVAR" => "???",
"TMPVARCV" => "EX_VAR(opline->op2.var)",
);
$op1_get_obj_zval_ptr = array(
"ANY" => "get_obj_zval_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op1)",
"UNUSED" => "&EX(This)",
"CV" => "_get_zval_ptr_cv_\\1(opline->op1.var EXECUTE_DATA_CC)",
"TMPVAR" => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"TMPVARCV" => "???",
);
$op2_get_obj_zval_ptr = array(
"ANY" => "get_obj_zval_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op2)",
"UNUSED" => "&EX(This)",
"CV" => "_get_zval_ptr_cv_\\1(opline->op2.var EXECUTE_DATA_CC)",
"TMPVAR" => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"TMPVARCV" => "???",
);
$op1_get_obj_zval_ptr_undef = array(
"ANY" => "get_obj_zval_ptr_undef(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op1)",
"UNUSED" => "&EX(This)",
"CV" => "EX_VAR(opline->op1.var)",
"TMPVAR" => "_get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"TMPVARCV" => "EX_VAR(opline->op1.var)",
);
$op2_get_obj_zval_ptr_undef = array(
"ANY" => "get_obj_zval_ptr_undef(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op2)",
"UNUSED" => "&EX(This)",
"CV" => "EX_VAR(opline->op2.var)",
"TMPVAR" => "_get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"TMPVARCV" => "EX_VAR(opline->op2.var)",
);
$op1_get_obj_zval_ptr_deref = array(
"ANY" => "get_obj_zval_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var_deref(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op1)",
"UNUSED" => "&EX(This)",
"CV" => "_get_zval_ptr_cv_deref_\\1(opline->op1.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op2_get_obj_zval_ptr_deref = array(
"ANY" => "get_obj_zval_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "_get_zval_ptr_tmp(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var_deref(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT(opline, opline->op2)",
"UNUSED" => "&EX(This)",
"CV" => "_get_zval_ptr_cv_deref_\\1(opline->op2.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op1_get_obj_zval_ptr_ptr = array(
"ANY" => "get_obj_zval_ptr_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "NULL",
"VAR" => "_get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "NULL",
"UNUSED" => "&EX(This)",
"CV" => "_get_zval_ptr_cv_\\1(opline->op1.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op2_get_obj_zval_ptr_ptr = array(
"ANY" => "get_obj_zval_ptr_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "NULL",
"VAR" => "_get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "NULL",
"UNUSED" => "&EX(This)",
"CV" => "_get_zval_ptr_cv_\\1(opline->op2.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op1_get_obj_zval_ptr_ptr_undef = array(
"ANY" => "get_obj_zval_ptr_ptr(opline->op1_type, opline->op1, &free_op1, \\1)",
"TMP" => "NULL",
"VAR" => "_get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC)",
"CONST" => "NULL",
"UNUSED" => "&EX(This)",
"CV" => "EX_VAR(opline->op1.var)",
"TMPVAR" => "???",
"TMPVARCV" => "EX_VAR(opline->op1.var)",
);
$op2_get_obj_zval_ptr_ptr_undef = array(
"ANY" => "get_obj_zval_ptr_ptr(opline->op2_type, opline->op2, &free_op2, \\1)",
"TMP" => "NULL",
"VAR" => "_get_zval_ptr_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC)",
"CONST" => "NULL",
"UNUSED" => "&EX(This)",
"CV" => "EX_VAR(opline->op2.var)",
"TMPVAR" => "???",
"TMPVARCV" => "EX_VAR(opline->op2.var)",
);
$op1_free_op = array(
"ANY" => "FREE_OP(free_op1)",
"TMP" => "zval_ptr_dtor_nogc(free_op1)",
"VAR" => "zval_ptr_dtor_nogc(free_op1)",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "zval_ptr_dtor_nogc(free_op1)",
"TMPVARCV" => "???",
);
$op2_free_op = array(
"ANY" => "FREE_OP(free_op2)",
"TMP" => "zval_ptr_dtor_nogc(free_op2)",
"VAR" => "zval_ptr_dtor_nogc(free_op2)",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "zval_ptr_dtor_nogc(free_op2)",
"TMPVARCV" => "???",
);
$op1_free_op_if_var = array(
"ANY" => "if (opline->op1_type == IS_VAR) {zval_ptr_dtor_nogc(free_op1);}",
"TMP" => "",
"VAR" => "zval_ptr_dtor_nogc(free_op1)",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op2_free_op_if_var = array(
"ANY" => "if (opline->op2_type == IS_VAR) {zval_ptr_dtor_nogc(free_op2);}",
"TMP" => "",
"VAR" => "zval_ptr_dtor_nogc(free_op2)",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op1_free_op_var_ptr = array(
"ANY" => "if (free_op1) {zval_ptr_dtor_nogc(free_op1);}",
"TMP" => "",
"VAR" => "if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);}",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op2_free_op_var_ptr = array(
"ANY" => "if (free_op2) {zval_ptr_dtor_nogc(free_op2);}",
"TMP" => "",
"VAR" => "if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);}",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op1_free_unfetched = array(
"ANY" => "FREE_UNFETCHED_OP(opline->op1_type, opline->op1.var)",
"TMP" => "zval_ptr_dtor_nogc(EX_VAR(opline->op1.var))",
"VAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op1.var))",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op1.var))",
"TMPVARCV" => "???",
);
$op2_free_unfetched = array(
"ANY" => "FREE_UNFETCHED_OP(opline->op2_type, opline->op2.var)",
"TMP" => "zval_ptr_dtor_nogc(EX_VAR(opline->op2.var))",
"VAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op2.var))",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op2.var))",
"TMPVARCV" => "???",
);
$op_data_type = array(
"ANY" => "(opline+1)->op1_type",
"TMP" => "IS_TMP_VAR",
"VAR" => "IS_VAR",
"CONST" => "IS_CONST",
"UNUSED" => "IS_UNUSED",
"CV" => "IS_CV",
"TMPVAR" => "(IS_TMP_VAR|IS_VAR)",
"TMPVARCV" => "(IS_TMP_VAR|IS_VAR|IS_CV)",
);
$op_data_get_zval_ptr = array(
"ANY" => "get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data)",
"TMP" => "_get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT((opline+1), (opline+1)->op1)",
"UNUSED" => "NULL",
"CV" => "_get_zval_ptr_cv_\\1((opline+1)->op1.var EXECUTE_DATA_CC)",
"TMPVAR" => "_get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
"TMPVARCV" => "???",
);
$op_data_get_zval_ptr_deref = array(
"ANY" => "get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data)",
"TMP" => "_get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
"VAR" => "_get_zval_ptr_var_deref((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
"CONST" => "RT_CONSTANT((opline+1), (opline+1)->op1)",
"UNUSED" => "NULL",
"CV" => "_get_zval_ptr_cv_deref_\\1((opline+1)->op1.var EXECUTE_DATA_CC)",
"TMPVAR" => "???",
"TMPVARCV" => "???",
);
$op_data_free_op = array(
"ANY" => "FREE_OP(free_op_data)",
"TMP" => "zval_ptr_dtor_nogc(free_op_data)",
"VAR" => "zval_ptr_dtor_nogc(free_op_data)",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "zval_ptr_dtor_nogc(free_op_data)",
"TMPVARCV" => "???",
);
$op_data_free_unfetched = array(
"ANY" => "FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var)",
"TMP" => "zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var))",
"VAR" => "zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var))",
"CONST" => "",
"UNUSED" => "",
"CV" => "",
"TMPVAR" => "zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var))",
"TMPVARCV" => "???",
);
$list = array(); // list of opcode handlers and helpers in original order
$opcodes = array(); // opcode handlers by code
$helpers = array(); // opcode helpers by name
$params = array(); // parameters of helpers
$opnames = array(); // opcode name to code mapping
$line_no = 1;
$used_extra_spec = array();
// Writes $s into resulting executor
function out($f, $s) {
global $line_no;
fputs($f,$s);
$line_no += substr_count($s, "\n");
}
// Resets #line directives in resulting executor
function out_line($f) {
global $line_no, $executor_file;
fputs($f,"#line ".($line_no+1)." \"".$executor_file."\"\n");
++$line_no;
}
function is_hot_helper($name) {
global $helpers;
if (isset($helpers[$name]["hot"])) {
return $helpers[$name]["hot"];
} else {
return false;
}
}
// Returns name of specialized helper
function helper_name($name, $spec, $op1, $op2, $extra_spec) {
global $prefix, $helpers;
$extra = "";
if (isset($helpers[$name])) {
// If we haven't helper with specified spicialized operands then
// using unspecialized helper
if (!isset($helpers[$name]["op1"][$op1])) {
if (($op1 == 'TMP' || $op1 == 'VAR') &&
isset($helpers[$name]["op1"]["TMPVAR"])) {
$op1 = "TMPVAR";
} else if (($op1 == 'TMP' || $op1 == 'VAR') &&
isset($helpers[$name]["op1"]["TMPVARCV"])) {
$op1 = "TMPVARCV";
} else if ($op1 == 'CV' &&
isset($helpers[$name]["op1"]["TMPVARCV"])) {
$op1 = "TMPVARCV";
} else if (isset($helpers[$name]["op1"]["ANY"])) {
$op1 = "ANY";
}
}
if (!isset($helpers[$name]["op2"][$op2])) {
if (($op2 == 'TMP' || $op2 == 'VAR') &&
isset($helpers[$name]["op2"]["TMPVAR"])) {
$op2 = "TMPVAR";
} else if (($op2 == 'TMP' || $op2 == 'VAR') &&
isset($helpers[$name]["op2"]["TMPVARCV"])) {
$op2 = "TMPVARCV";
} else if ($op2 == 'CV' &&
isset($helpers[$name]["op2"]["TMPVARCV"])) {
$op2 = "TMPVARCV";
} else if (isset($helpers[$name]["op2"]["ANY"])) {
$op2 = "ANY";
}
}
/* forward common specs (e.g. in ZEND_VM_DISPATCH_TO_HELPER) */
if (isset($extra_spec, $helpers[$name]["spec"])) {
$extra = extra_spec_name(array_intersect_key($extra_spec, $helpers[$name]["spec"]));
}
}
return $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].$extra;
}
function opcode_name($name, $spec, $op1, $op2) {
global $prefix, $opnames, $opcodes;
if (isset($opnames[$name])) {
$opcode = $opcodes[$opnames[$name]];
// If we haven't helper with specified spicialized operands then
// using unspecialized helper
if (!isset($opcode["op1"][$op1])) {
if (($op1 == 'TMP' || $op1 == 'VAR') &&
isset($opcode["op1"]["TMPVAR"])) {
$op1 = "TMPVAR";
} else if (($op1 == 'TMP' || $op1 == 'VAR') &&
isset($opcode["op1"]["TMPVARCV"])) {
$op1 = "TMPVARCV";
} else if ($op1 == 'CV' &&
isset($opcode["op1"]["TMPVARCV"])) {
$op1 = "TMPVARCV";
} else if (isset($opcode["op1"]["ANY"])) {
$op1 = "ANY";
} else if ($spec) {
/* dispatch to invalid handler from unreachable code */
return "ZEND_NULL";
}
}
if (!isset($opcode["op2"][$op2])) {
if (($op2 == 'TMP' || $op2 == 'VAR') &&
isset($opcode["op2"]["TMPVAR"])) {
$op2 = "TMPVAR";
} else if (($op2 == 'TMP' || $op2 == 'VAR') &&
isset($opcode["op2"]["TMPVARCV"])) {
$op2 = "TMPVARCV";
} else if ($op2 == 'CV' &&
isset($opcode["op2"]["TMPVARCV"])) {
$op2 = "TMPVARCV";
} else if (isset($opcode["op2"]["ANY"])) {
$op2 = "ANY";
} else if ($spec) {
/* dispatch to unknown handler in unreachable code */
return "ZEND_NULL";
}
}
}
return $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2];
}
// Formats condition, protecting it by parentheses when needed.
function format_condition($condition) {
if ($condition === "") {
throw new InvalidArgumentException("A non empty string condition was expected.");
}
if ($condition[0] === "(" && substr($condition, -1) === ")") {
return $condition;
}
return "(".$condition.")";
}
// Generates code for opcode handler or helper
function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_spec=null) {
global $op1_type, $op2_type, $op1_get_zval_ptr, $op2_get_zval_ptr,
$op1_get_zval_ptr_deref, $op2_get_zval_ptr_deref,
$op1_get_zval_ptr_undef, $op2_get_zval_ptr_undef,
$op1_get_zval_ptr_ptr, $op2_get_zval_ptr_ptr,
$op1_get_zval_ptr_ptr_undef, $op2_get_zval_ptr_ptr_undef,
$op1_get_obj_zval_ptr, $op2_get_obj_zval_ptr,
$op1_get_obj_zval_ptr_undef, $op2_get_obj_zval_ptr_undef,
$op1_get_obj_zval_ptr_deref, $op2_get_obj_zval_ptr_deref,
$op1_get_obj_zval_ptr_ptr, $op2_get_obj_zval_ptr_ptr,
$op1_get_obj_zval_ptr_ptr_undef, $op2_get_obj_zval_ptr_ptr_undef,
$op1_free, $op2_free, $op1_free_unfetched, $op2_free_unfetched,
$op1_free_op, $op2_free_op, $op1_free_op_if_var, $op2_free_op_if_var,
$op1_free_op_var_ptr, $op2_free_op_var_ptr, $prefix,
$op_data_type, $op_data_get_zval_ptr, $op_data_get_zval_ptr_deref,
$op_data_free_op, $op_data_free_unfetched;
// Specializing
$code = preg_replace(
array(
"/OP1_TYPE/",
"/OP2_TYPE/",
"/OP1_FREE/",
"/OP2_FREE/",
"/GET_OP1_ZVAL_PTR\(([^)]*)\)/",
"/GET_OP2_ZVAL_PTR\(([^)]*)\)/",
"/GET_OP1_ZVAL_PTR_DEREF\(([^)]*)\)/",
"/GET_OP2_ZVAL_PTR_DEREF\(([^)]*)\)/",
"/GET_OP1_ZVAL_PTR_UNDEF\(([^)]*)\)/",
"/GET_OP2_ZVAL_PTR_UNDEF\(([^)]*)\)/",
"/GET_OP1_ZVAL_PTR_PTR\(([^)]*)\)/",
"/GET_OP2_ZVAL_PTR_PTR\(([^)]*)\)/",
"/GET_OP1_ZVAL_PTR_PTR_UNDEF\(([^)]*)\)/",
"/GET_OP2_ZVAL_PTR_PTR_UNDEF\(([^)]*)\)/",
"/GET_OP1_OBJ_ZVAL_PTR\(([^)]*)\)/",
"/GET_OP2_OBJ_ZVAL_PTR\(([^)]*)\)/",
"/GET_OP1_OBJ_ZVAL_PTR_UNDEF\(([^)]*)\)/",
"/GET_OP2_OBJ_ZVAL_PTR_UNDEF\(([^)]*)\)/",
"/GET_OP1_OBJ_ZVAL_PTR_DEREF\(([^)]*)\)/",
"/GET_OP2_OBJ_ZVAL_PTR_DEREF\(([^)]*)\)/",
"/GET_OP1_OBJ_ZVAL_PTR_PTR\(([^)]*)\)/",
"/GET_OP2_OBJ_ZVAL_PTR_PTR\(([^)]*)\)/",
"/GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF\(([^)]*)\)/",
"/GET_OP2_OBJ_ZVAL_PTR_PTR_UNDEF\(([^)]*)\)/",
"/FREE_OP1\(\)/",
"/FREE_OP2\(\)/",
"/FREE_OP1_IF_VAR\(\)/",
"/FREE_OP2_IF_VAR\(\)/",
"/FREE_OP1_VAR_PTR\(\)/",
"/FREE_OP2_VAR_PTR\(\)/",
"/FREE_UNFETCHED_OP1\(\)/",
"/FREE_UNFETCHED_OP2\(\)/",
"/^#(\s*)ifdef\s+ZEND_VM_SPEC\s*\n/m",
"/^#(\s*)ifndef\s+ZEND_VM_SPEC\s*\n/m",
"/\!defined\(ZEND_VM_SPEC\)/m",
"/defined\(ZEND_VM_SPEC\)/m",
"/ZEND_VM_C_LABEL\(\s*([A-Za-z_]*)\s*\)/m",
"/ZEND_VM_C_GOTO\(\s*([A-Za-z_]*)\s*\)/m",
"/^#(\s*)if\s+1\s*\\|\\|.*[^\\\\]$/m",
"/^#(\s*)if\s+0\s*&&.*[^\\\\]$/m",
"/^#(\s*)ifdef\s+ZEND_VM_EXPORT\s*\n/m",
"/^#(\s*)ifndef\s+ZEND_VM_EXPORT\s*\n/m",
"/OP_DATA_TYPE/",
"/GET_OP_DATA_ZVAL_PTR\(([^)]*)\)/",
"/GET_OP_DATA_ZVAL_PTR_DEREF\(([^)]*)\)/",
"/FREE_OP_DATA\(\)/",
"/FREE_UNFETCHED_OP_DATA\(\)/",
"/RETURN_VALUE_USED\(opline\)/",
"/arg_num <= MAX_ARG_FLAG_NUM/",
"/ZEND_VM_SMART_BRANCH\(\s*([^,)]*)\s*,\s*([^)]*)\s*\)/",
"/opline->extended_value\s*==\s*0/",
"/opline->extended_value\s*==\s*ZEND_ASSIGN_DIM/",
"/opline->extended_value\s*==\s*ZEND_ASSIGN_OBJ/",
"/opline->extended_value\s*&\s*ZEND_ISEMPTY/",
"/opline->extended_value\s*&\s*~\s*ZEND_ISEMPTY/",
),
array(
$op1_type[$op1],
$op2_type[$op2],
$op1_free[$op1],
$op2_free[$op2],
$op1_get_zval_ptr[$op1],
$op2_get_zval_ptr[$op2],
$op1_get_zval_ptr_deref[$op1],
$op2_get_zval_ptr_deref[$op2],
$op1_get_zval_ptr_undef[$op1],
$op2_get_zval_ptr_undef[$op2],
$op1_get_zval_ptr_ptr[$op1],
$op2_get_zval_ptr_ptr[$op2],
$op1_get_zval_ptr_ptr_undef[$op1],
$op2_get_zval_ptr_ptr_undef[$op2],
$op1_get_obj_zval_ptr[$op1],
$op2_get_obj_zval_ptr[$op2],
$op1_get_obj_zval_ptr_undef[$op1],
$op2_get_obj_zval_ptr_undef[$op2],
$op1_get_obj_zval_ptr_deref[$op1],
$op2_get_obj_zval_ptr_deref[$op2],
$op1_get_obj_zval_ptr_ptr[$op1],
$op2_get_obj_zval_ptr_ptr[$op2],
$op1_get_obj_zval_ptr_ptr_undef[$op1],
$op2_get_obj_zval_ptr_ptr_undef[$op2],
$op1_free_op[$op1],
$op2_free_op[$op2],
$op1_free_op_if_var[$op1],
$op2_free_op_if_var[$op2],
$op1_free_op_var_ptr[$op1],
$op2_free_op_var_ptr[$op2],
$op1_free_unfetched[$op1],
$op2_free_unfetched[$op2],
($op1!="ANY"||$op2!="ANY")?"#\\1if 1\n":"#\\1if 0\n",
($op1!="ANY"||$op2!="ANY")?"#\\1if 0\n":"#\\1if 1\n",
($op1!="ANY"||$op2!="ANY")?"0":"1",
($op1!="ANY"||$op2!="ANY")?"1":"0",
"\\1".(($spec && $kind != ZEND_VM_KIND_CALL)?("_SPEC".$prefix[$op1].$prefix[$op2].extra_spec_name($extra_spec)):""),
"goto \\1".(($spec && $kind != ZEND_VM_KIND_CALL)?("_SPEC".$prefix[$op1].$prefix[$op2].extra_spec_name($extra_spec)):""),
"#\\1if 1",
"#\\1if 0",
$export?"#\\1if 1\n":"#\\1if 0\n",
$export?"#\\1if 0\n":"#\\1if 1\n",
$op_data_type[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
$op_data_get_zval_ptr[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
$op_data_get_zval_ptr_deref[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
$op_data_free_op[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
$op_data_free_unfetched[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
isset($extra_spec['RETVAL']) ? $extra_spec['RETVAL'] : "RETURN_VALUE_USED(opline)",
isset($extra_spec['QUICK_ARG']) ? $extra_spec['QUICK_ARG'] : "arg_num <= MAX_ARG_FLAG_NUM",
isset($extra_spec['SMART_BRANCH']) ?
($extra_spec['SMART_BRANCH'] == 1 ?
"ZEND_VM_SMART_BRANCH_JMPZ(\\1, \\2)"
: ($extra_spec['SMART_BRANCH'] == 2 ?
"ZEND_VM_SMART_BRANCH_JMPNZ(\\1, \\2)" : ""))
: "ZEND_VM_SMART_BRANCH(\\1, \\2)",
isset($extra_spec['DIM_OBJ']) ?
($extra_spec['DIM_OBJ'] == 0 ? "1" : "0")
: "\\0",
isset($extra_spec['DIM_OBJ']) ?
($extra_spec['DIM_OBJ'] == 1 ? "1" : "0")
: "\\0",
isset($extra_spec['DIM_OBJ']) ?
($extra_spec['DIM_OBJ'] == 2 ? "1" : "0")
: "\\0",
isset($extra_spec['ISSET']) ?
($extra_spec['ISSET'] == 0 ? "0" : "1")
: "\\0",
isset($extra_spec['ISSET']) ?
($extra_spec['ISSET'] == 0 ? "\\0" : "opline->extended_value")
: "\\0",
),
$code);
if (0 && strpos($code, '{') === 0) {
$code = "{\n\tfprintf(stderr, \"$name\\n\");\n" . substr($code, 1);
}
// Updating code according to selected threading model
switch($kind) {
case ZEND_VM_KIND_HYBRID:
$code = preg_replace_callback(
array(
"/EXECUTE_DATA(?=[^_])/m",
"/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
"/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*(,[^)]*)?\)/m",
),
function($matches) use ($spec, $prefix, $op1, $op2, $extra_spec) {
if (strncasecmp($matches[0], "EXECUTE_DATA", strlen("EXECUTE_DATA")) == 0) {
return "execute_data";
} else if (strncasecmp($matches[0], "ZEND_VM_DISPATCH_TO_HANDLER", strlen("ZEND_VM_DISPATCH_TO_HANDLER")) == 0) {
global $opcodes, $opnames;
$name = $matches[1];
$opcode = $opcodes[$opnames[$name]];
if (is_hot_handler($opcode["hot"], $op1, $op2, $extra_spec)) {
return "goto " . opcode_name($name, $spec, $op1, $op2) . "_LABEL";
} else {
return "ZEND_VM_TAIL_CALL(" . opcode_name($name, $spec, $op1, $op2) . "_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU))";
}
} else {
// ZEND_VM_DISPATCH_TO_HELPER
if (isset($matches[2])) {
// extra args
$args = substr(preg_replace("/,\s*[A-Za-z_]*\s*,\s*([^,)\s]*)\s*/", ", $1", $matches[2]), 2);
return "ZEND_VM_TAIL_CALL(" . helper_name($matches[1], $spec, $op1, $op2, $extra_spec) . "(" . $args. " ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC))";
}
if (is_hot_helper($matches[1])) {
return "goto " . helper_name($matches[1], $spec, $op1, $op2, $extra_spec) . "_LABEL";
}
return "ZEND_VM_TAIL_CALL(" . helper_name($matches[1], $spec, $op1, $op2, $extra_spec) . "(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU))";
}
},
$code);
break;
case ZEND_VM_KIND_CALL:
$code = preg_replace_callback(
array(
"/EXECUTE_DATA(?=[^_])/m",
"/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
"/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*(,[^)]*)?\)/m",
),
function($matches) use ($spec, $prefix, $op1, $op2, $extra_spec) {
if (strncasecmp($matches[0], "EXECUTE_DATA", strlen("EXECUTE_DATA")) == 0) {
return "execute_data";
} else if (strncasecmp($matches[0], "ZEND_VM_DISPATCH_TO_HANDLER", strlen("ZEND_VM_DISPATCH_TO_HANDLER")) == 0) {
return "ZEND_VM_TAIL_CALL(" . opcode_name($matches[1], $spec, $op1, $op2) . "_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU))";
} else {
// ZEND_VM_DISPATCH_TO_HELPER
if (isset($matches[2])) {
// extra args
$args = substr(preg_replace("/,\s*[A-Za-z_]*\s*,\s*([^,)\s]*)\s*/", ", $1", $matches[2]), 2);
return "ZEND_VM_TAIL_CALL(" . helper_name($matches[1], $spec, $op1, $op2, $extra_spec) . "(" . $args. " ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC))";
}
return "ZEND_VM_TAIL_CALL(" . helper_name($matches[1], $spec, $op1, $op2, $extra_spec) . "(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU))";
}
},
$code);
break;
case ZEND_VM_KIND_SWITCH:
$code = preg_replace_callback(
array(
"/EXECUTE_DATA(?=[^_])/m",
"/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
"/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*(,[^)]*)?\)/m",
),
function($matches) use ($spec, $prefix, $op1, $op2, $extra_spec) {
if (strncasecmp($matches[0], "EXECUTE_DATA", strlen("EXECUTE_DATA")) == 0) {
return "execute_data";
} else if (strncasecmp($matches[0], "ZEND_VM_DISPATCH_TO_HANDLER", strlen("ZEND_VM_DISPATCH_TO_HANDLER")) == 0) {
return "goto " . opcode_name($matches[1], $spec, $op1, $op2) . "_LABEL";
} else {
// ZEND_VM_DISPATCH_TO_HELPER
if (isset($matches[2])) {
// extra args
$args = preg_replace("/,\s*([A-Za-z_]*)\s*,\s*([^,)\s]*)\s*/", "$1 = $2; ", $matches[2]);
return $args . "goto " . helper_name($matches[1], $spec, $op1, $op2, $extra_spec);
}
return "goto " . helper_name($matches[1], $spec, $op1, $op2, $extra_spec);
}
},
$code);
break;
case ZEND_VM_KIND_GOTO:
$code = preg_replace_callback(
array(
"/EXECUTE_DATA(?=[^_])/m",
"/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m",
"/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*(,[^)]*)?\)/m",
),
function($matches) use ($spec, $prefix, $op1, $op2, $extra_spec) {
if (strncasecmp($matches[0], "EXECUTE_DATA", strlen("EXECUTE_DATA")) == 0) {
return "execute_data";
} else if (strncasecmp($matches[0], "ZEND_VM_DISPATCH_TO_HANDLER", strlen("ZEND_VM_DISPATCH_TO_HANDLER")) == 0) {
return "goto " . opcode_name($matches[1], $spec, $op1, $op2) . "_LABEL";
} else {
// ZEND_VM_DISPATCH_TO_HELPER
if (isset($matches[2])) {
// extra args
$args = preg_replace("/,\s*([A-Za-z_]*)\s*,\s*([^,)\s]*)\s*/", "$1 = $2; ", $matches[2]);
return $args . "goto " . helper_name($matches[1], $spec, $op1, $op2, $extra_spec);
}
return "goto " . helper_name($matches[1], $spec, $op1, $op2, $extra_spec);
}
},
$code);
break;
}
/* Remove unused free_op1 and free_op2 declarations */
if ($spec && preg_match_all('/^\s*zend_free_op\s+[^;]+;\s*$/me', $code, $matches, PREG_SET_ORDER)) {
$n = 0;
foreach ($matches as $match) {
$code = preg_replace('/'.preg_quote($match[0],'/').'/', "\$D$n", $code);
++$n;
}
$del_free_op1 = (strpos($code, "free_op1") === false);
$del_free_op2 = (strpos($code, "free_op2") === false);
$del_free_op_data = (strpos($code, "free_op_data") === false);
$n = 0;
foreach ($matches as $match) {
$dcl = $match[0];
$changed = 0;
if ($del_free_op1 && strpos($dcl, "free_op1") !== false) {
$dcl = preg_replace("/free_op1\s*,\s*/", "", $dcl);
$dcl = preg_replace("/free_op1\s*;/", ";", $dcl);
$changed = 1;
}
if ($del_free_op2 && strpos($dcl, "free_op2") !== false) {
$dcl = preg_replace("/free_op2\s*,\s*/", "", $dcl);
$dcl = preg_replace("/free_op2\s*;/", ";", $dcl);
$changed = 1;
}
if ($del_free_op_data && strpos($dcl, "free_op_data") !== false) {
$dcl = preg_replace("/free_op_data\s*,\s*/", "", $dcl);
$dcl = preg_replace("/free_op_data\s*;/", ";", $dcl);
$changed = 1;
}
if ($changed) {
$dcl = preg_replace("/,\s*;/", ";", $dcl);
$dcl = preg_replace("/zend_free_op\s*;/", "", $dcl);
}
$code = preg_replace("/\\\$D$n/", $dcl, $code);
++$n;
}
}
/* Remove unnecessary ';' */
$code = preg_replace('/^\s*;\s*$/m', '', $code);
/* Remove WS */
$code = preg_replace('/[ \t]+\n/m', "\n", $code);
out($f, $code);
}
function skip_extra_spec_function($op1, $op2, $extra_spec) {
global $commutative_order;
if (isset($extra_spec["NO_CONST_CONST"]) &&
$op1 == "CONST" && $op2 == "CONST") {
// Skip useless constant handlers
return true;
}
if (isset($extra_spec["COMMUTATIVE"]) &&
$commutative_order[$op1] < $commutative_order[$op2]) {
// Skip duplicate commutative handlers
return true;
}
if (isset($extra_spec["DIM_OBJ"]) &&
(($op2 == "UNUSED" && $extra_spec["DIM_OBJ"] != 1) ||
($op1 == "UNUSED" && $extra_spec["DIM_OBJ"] != 2))) {
// Skip useless handlers
return true;
}
return false;
}
function is_hot_handler($hot, $op1, $op2, $extra_spec) {
if ($hot === 'HOT_') {
return true;
} else if ($hot === 'HOT_NOCONST_') {
return ($op1 !== 'CONST');
} else if ($hot === 'HOT_OBJ_') {
return (($op1 === 'UNUSED') || ($op1 === 'CV')) && ($op2 === 'CONST');
} else if ($hot === 'HOT_SEND_') {
return !empty($extra_spec["QUICK_ARG"]);
} else {
return false;
}
}
function is_cold_handler($hot, $op1, $op2, $extra_spec) {
if ($hot === 'COLD_') {
return true;
} else if ($hot === 'COLD_CONST_') {
return ($op1 === 'CONST');
} else if ($hot === 'COLD_CONSTCONST_') {
return ($op1 === 'CONST' && $op2 === 'CONST');
} else if ($hot === 'HOT_OBJ_') {
return ($op1 === 'CONST');
} else if ($hot === 'HOT_NOCONST_') {
return ($op1 === 'CONST');
} else {
return false;
}
}
function is_inline_hybrid_handler($name, $hot, $op1, $op2, $extra_spec) {
return $name == "ZEND_RETURN";
//return $hot && is_hot_handler($hot, $op1, $op2, $extra_spec);
}
// Generates opcode handler
function gen_handler($f, $spec, $kind, $name, $op1, $op2, $use, $code, $lineno, $opcode, $extra_spec = null, &$switch_labels = array()) {
global $definition_file, $prefix, $opnames, $gen_order;
if ($spec && skip_extra_spec_function($op1, $op2, $extra_spec)) {
return;
}
if (ZEND_VM_LINES) {
out($f, "#line $lineno \"$definition_file\"\n");
}
// Generate opcode handler's entry point according to selected threading model
$spec_name = $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].($spec?extra_spec_name($extra_spec):"");
switch($kind) {
case ZEND_VM_KIND_HYBRID:
if (is_inline_hybrid_handler($name, $opcode["hot"], $op1, $op2, $extra_spec)) {
$out = fopen('php://memory', 'w+');
gen_code($out, $spec, $kind, 0, $code, $op1, $op2, $name, $extra_spec);
rewind($out);
$code =
"\t\t\tHYBRID_CASE({$spec_name}):\n"
. "\t\t\t\tVM_TRACE($spec_name)\n"
. stream_get_contents($out);
fclose($out);
} else {
$code =
"\t\t\tHYBRID_CASE({$spec_name}):\n"
. "\t\t\t\tVM_TRACE($spec_name)\n"
. "\t\t\t\t{$spec_name}_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n"
. "\t\t\t\tHYBRID_BREAK();\n";
}
if (is_array($gen_order)) {
$gen_order[$spec_name] = $code;
} else {
out($f, $code);
}
return;
case ZEND_VM_KIND_CALL:
if ($opcode["hot"] && ZEND_VM_KIND == ZEND_VM_KIND_HYBRID && is_hot_handler($opcode["hot"], $op1, $op2, $extra_spec)) {
out($f,"static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL {$spec_name}_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n");
} else if ($opcode["hot"] && is_cold_handler($opcode["hot"], $op1, $op2, $extra_spec)) {
out($f,"static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL {$spec_name}_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n");
} else {
out($f,"static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL {$spec_name}_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n");
}
break;
case ZEND_VM_KIND_SWITCH:
if ($spec) {
$cur = $switch_labels ? end($switch_labels) + 1 : 0;
out($f,"case $cur: /* $spec_name */");
$switch_labels[$spec_name] = $cur;
} else {
out($f,"case ".$name.":");
}
if ($use) {
// This handler is used by other handlers. We will add label to call it.
out($f," {$spec_name}_LABEL:\n");
} else {
out($f,"\n");
}
break;
case ZEND_VM_KIND_GOTO:
out($f,"{$spec_name}_LABEL: ZEND_VM_GUARD($spec_name);\n");
break;
}
// Generate opcode handler's code
gen_code($f, $spec, $kind, 0, $code, $op1, $op2, $name, $extra_spec);
}
// Generates helper
function gen_helper($f, $spec, $kind, $name, $op1, $op2, $param, $code, $lineno, $inline, $cold = false, $hot = false, $extra_spec = null) {
global $definition_file, $prefix;
if ($kind == ZEND_VM_KIND_HYBRID && !$hot) {
return;
}
if ($spec && skip_extra_spec_function($op1, $op2, $extra_spec)) {
return;
}
if (ZEND_VM_LINES) {
out($f, "#line $lineno \"$definition_file\"\n");
}
$spec_name = $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].($spec?extra_spec_name($extra_spec):"");
// Generate helper's entry point according to selected threading model
switch($kind) {
case ZEND_VM_KIND_HYBRID:
out($f, $spec_name . "_LABEL:\n");
break;
case ZEND_VM_KIND_CALL:
if ($inline) {
$zend_attributes = " zend_always_inline";
$zend_fastcall = "";
} else {
if ($cold) {
$zend_attributes = " zend_never_inline ZEND_COLD";
} else {
$zend_attributes = "";
}
$zend_fastcall = " ZEND_FASTCALL";
}
if ($param == null) {
// Helper without parameters
out($f, "static$zend_attributes ZEND_OPCODE_HANDLER_RET$zend_fastcall $spec_name(ZEND_OPCODE_HANDLER_ARGS)\n");
} else {
// Helper with parameter
out($f, "static$zend_attributes ZEND_OPCODE_HANDLER_RET$zend_fastcall $spec_name($param ZEND_OPCODE_HANDLER_ARGS_DC)\n");
}
break;
case ZEND_VM_KIND_SWITCH:
out($f, "$spec_name:\n");
break;
case ZEND_VM_KIND_GOTO:
out($f, "$spec_name:\n");
break;
}
// Generate helper's code
gen_code($f, $spec, $kind, 0, $code, $op1, $op2, $name, $extra_spec);
}
function gen_null_label($f, $kind, $prolog) {
switch ($kind) {
case ZEND_VM_KIND_CALL:
out($f,$prolog."ZEND_NULL_HANDLER,\n");
break;
case ZEND_VM_KIND_SWITCH:
out($f,$prolog."(void*)(uintptr_t)-1,\n");
break;
case ZEND_VM_KIND_GOTO:
out($f,$prolog."(void*)&&ZEND_NULL_LABEL,\n");
break;
}
}
// Generates array of opcode handlers (specialized or unspecialized)
function gen_labels($f, $spec, $kind, $prolog, &$specs, $switch_labels = array()) {
global $opcodes, $op_types, $prefix, $op_types_ex;
$list = [];
$next = 0;
$label = 0;
if ($spec) {
// Emit labels for specialized executor
// For each opcode in opcode number order
foreach($opcodes as $num => $dsc) {
$specs[$num] = "$label";
$spec_op1 = $spec_op2 = $spec_extra = false;
$def_op1_type = $def_op2_type = "ANY";
$next = $num + 1;
if (isset($dsc["op1"]) && !isset($dsc["op1"]["ANY"])) {
$count = 0;
foreach ($op_types_ex as $t) {
if (isset($dsc["op1"][$t])) {
$def_op1_type = $t;
$count++;
}
}
if ($count > 1) {
$spec_op1 = true;
$specs[$num] .= " | SPEC_RULE_OP1";
$def_op1_type = "ANY";
}
}
if (isset($dsc["op2"]) && !isset($dsc["op2"]["ANY"])) {
$count = 0;
foreach ($op_types_ex as $t) {
if (isset($dsc["op2"][$t])) {
$def_op2_type = $t;
$count++;
}
}
if ($count > 1) {
$spec_op2 = true;
$specs[$num] .= " | SPEC_RULE_OP2";
$def_op2_type = "ANY";
}
}
$spec_extra = call_user_func_array("array_merge", extra_spec_handler($dsc) ?: array(array()));
$flags = extra_spec_flags($spec_extra);
if ($flags) {
$specs[$num] .= " | " . implode(" | ", $flags);
}
if ($num >= 256) {
$opcodes[$num]['spec_code'] = $specs[$num];
unset($specs[$num]);
}
$foreach_op1 = function($do) use ($dsc, $op_types) {
return function($_, $op2) use ($do, $dsc, $op_types) {
// For each op1.op_type except ANY
foreach($op_types as $op1) {
if ($op1 != "ANY") {
if (!isset($dsc["op1"][$op1])) {
if ($op1 == "TMP" || $op1 == "VAR") {
if (isset($dsc["op1"]["TMPVAR"])) {
$op1 = "TMPVAR";
} else if (isset($dsc["op1"]["TMPVARCV"])) {
$op1 = "TMPVARCV";
} else {
$op1 = "ANY";
}
} else if ($op1 == "CV" && isset($dsc["op1"]["TMPVARCV"])) {
$op1 = "TMPVARCV";
} else {
// Try to use unspecialized handler
$op1 = "ANY";
}
}
$do($op1, $op2);
}
}
};
};
$foreach_op2 = function($do) use ($dsc, $op_types) {
return function($op1, $_) use ($do, $dsc, $op_types) {
// For each op2.op_type except ANY
foreach($op_types as $op2) {
if ($op2 != "ANY") {
if (!isset($dsc["op2"][$op2])) {
if ($op2 == "TMP" || $op2 == "VAR") {
if (isset($dsc["op2"]["TMPVAR"])) {
$op2 = "TMPVAR";
} else if (isset($dsc["op2"]["TMPVARCV"])) {
$op2 = "TMPVARCV";
} else {
$op2 = "ANY";
}
} else if ($op2 == "CV" && isset($dsc["op2"]["TMPVARCV"])) {
$op2 = "TMPVARCV";
} else {
// Try to use unspecialized handler
$op2 = "ANY";
}
}
$do($op1, $op2);
}
}
};
};
$foreach_op_data = function($do) use ($dsc, $op_types) {
return function($op1, $op2, $extra_spec = array()) use ($do, $dsc, $op_types) {
// For each op_data.op_type except ANY
foreach($op_types as $op_data) {
if ($op_data != "ANY") {
if (!isset($dsc["spec"]["OP_DATA"][$op_data])) {
if ($op_data == "TMP" || $op_data == "VAR") {
if (isset($dsc["spec"]["OP_DATA"]["TMPVAR"])) {
$op_data = "TMPVAR";
} else if (isset($dsc["spec"]["OP_DATA"]["TMPVARCV"])) {
$op_data = "TMPVARCV";
} else {
// Try to use unspecialized handler
$op_data = "ANY";
}
} else if ($op_data == "CV" && isset($dsc["OP_DATA"]["TMPVARCV"])) {
$op_data = "TMPVARCV";
} else {
// Try to use unspecialized handler
$op_data = "ANY";
}
}
$do($op1, $op2, array("OP_DATA" => $op_data) + $extra_spec);
}
}
};
};
$foreach_extra_spec = function($do, $spec) use ($dsc) {
return function($op1, $op2, $extra_spec = array()) use ($do, $spec, $dsc) {
foreach ($dsc["spec"][$spec] as $val) {
$do($op1, $op2, array($spec => $val) + $extra_spec);
}
};
};
$generate = function ($op1, $op2, $extra_spec = array()) use ($f, $kind, $dsc, $prefix, $prolog, $num, $switch_labels, &$label, &$list) {
global $commutative_order;
// Check if specialized handler is defined
/* TODO: figure out better way to signal "specialized and not defined" than an extra lookup */
if (isset($dsc["op1"][$op1]) &&
isset($dsc["op2"][$op2]) &&
(!isset($extra_spec["OP_DATA"]) || isset($dsc["spec"]["OP_DATA"][$extra_spec["OP_DATA"]]))) {
if (skip_extra_spec_function($op1, $op2, $extra_spec)) {
gen_null_label($f, $kind, $prolog);
$list[$label] = null;
$label++;
return;
}
// Emit pointer to specialized handler
$spec_name = $dsc["op"]."_SPEC".$prefix[$op1].$prefix[$op2].extra_spec_name($extra_spec);
switch ($kind) {
case ZEND_VM_KIND_CALL:
out($f,"$prolog{$spec_name}_HANDLER,\n");
break;
case ZEND_VM_KIND_SWITCH:
out($f,$prolog."(void*)(uintptr_t)$switch_labels[$spec_name],\n");
break;
case ZEND_VM_KIND_GOTO:
out($f,$prolog."(void*)&&{$spec_name}_LABEL,\n");
break;
}
$list[$label] = $spec_name;
$label++;
} else {
// Emit pointer to handler of undefined opcode
gen_null_label($f, $kind, $prolog);
$list[$label] = null;
$label++;
}
};
$do = $generate;
if ($spec_extra) {
foreach ($spec_extra as $extra => $devnull) {
if ($extra == "OP_DATA") {
$do = $foreach_op_data($do);
} else {
$do = $foreach_extra_spec($do, $extra);
}
}
}
if ($spec_op2) {
$do = $foreach_op2($do);
}
if ($spec_op1) {
$do = $foreach_op1($do);
}
$do($def_op1_type, $def_op2_type);
}
} else {
// Emit labels for unspecialized executor
// For each opcode in opcode number order
foreach($opcodes as $num => $dsc) {
while ($next != $num) {
// If some opcode numbers are not used then fill hole with pointers
// to handler of undefined opcode
switch ($kind) {
case ZEND_VM_KIND_CALL:
out($f,$prolog."ZEND_NULL_HANDLER,\n");
break;
case ZEND_VM_KIND_SWITCH:
out($f,$prolog."(void*)(uintptr_t)-1,\n");
break;
case ZEND_VM_KIND_GOTO:
out($f,$prolog."(void*)&&ZEND_NULL_LABEL,\n");
break;
}
$next++;
}
if ($num >= 256) {
continue;
}
$next = $num+1;
//ugly trick for ZEND_VM_DEFINE_OP
if ($dsc["code"]) {
// Emit pointer to unspecialized handler
switch ($kind) {
case ZEND_VM_KIND_CALL:
out($f,$prolog.$dsc["op"]."_HANDLER,\n");
break;
case ZEND_VM_KIND_SWITCH:
out($f,$prolog."(void*)(uintptr_t)".((string)$num).",\n");
break;
case ZEND_VM_KIND_GOTO:
out($f,$prolog."(void*)&&".$dsc["op"]."_LABEL,\n");
break;
}
$list[] = $dsc["op"];
} else {
switch ($kind) {
case ZEND_VM_KIND_CALL:
out($f,$prolog."ZEND_NULL_HANDLER,\n");
break;
case ZEND_VM_KIND_SWITCH:
out($f,$prolog."(void*)(uintptr_t)-1,\n");
break;
case ZEND_VM_KIND_GOTO:
out($f,$prolog."(void*)&&ZEND_NULL_LABEL,\n");
break;
}
$list[] = null;
}
}
}
// Emit last handler's label (undefined opcode)
switch ($kind) {
case ZEND_VM_KIND_CALL:
out($f,$prolog."ZEND_NULL_HANDLER\n");
break;
case ZEND_VM_KIND_SWITCH:
out($f,$prolog."(void*)(uintptr_t)-1\n");
break;
case ZEND_VM_KIND_GOTO:
out($f,$prolog."(void*)&&ZEND_NULL_LABEL\n");
break;
}
$specs[$num + 1] = "$label";
$l = fopen(__DIR__ . "/zend_vm_handlers.h", "w+") or die("ERROR: Cannot create zend_vm_handlers.h\n");
out($l, "#define VM_HANDLERS(_) \\\n");
foreach ($list as $n => $name) {
if (!is_null($name)) {
out($l, "\t_($n, $name) \\\n");
}
}
out($l, "\t_($n+1, ZEND_NULL)\n");
fclose($l);
}
// Generates specialized offsets
function gen_specs($f, $prolog, $specs) {
$lastdef = array_pop($specs);
$last = 0;
foreach ($specs as $num => $def) {
while (++$last < $num) {
out($f, "$prolog$lastdef,\n");
}
$last = $num;
out($f, "$prolog$def,\n");
}
out($f, "$prolog$lastdef\n");
}
// Generates handler for undefined opcodes (CALL threading model)
function gen_null_handler($f) {
static $done = 0;
// New and all executors with CALL threading model can use the same handler
// for undefined opcodes, do we emit code for it only once
if (!$done) {
$done = 1;
out($f,"static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n");
out($f,"{\n");
out($f,"\tUSE_OPLINE\n");
out($f,"\n");
out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);\n");
out($f,"\tZEND_VM_NEXT_OPCODE(); /* Never reached */\n");
out($f,"}\n\n");
}
}
function extra_spec_name($extra_spec) {
global $prefix;
$s = "";
if (isset($extra_spec["OP_DATA"])) {
$s .= "_OP_DATA" . $prefix[$extra_spec["OP_DATA"]];
}
if (isset($extra_spec["RETVAL"])) {
$s .= "_RETVAL_".($extra_spec["RETVAL"] ? "USED" : "UNUSED");
}
if (isset($extra_spec["QUICK_ARG"])) {
if ($extra_spec["QUICK_ARG"]) {
$s .= "_QUICK";
}
}
if (isset($extra_spec["SMART_BRANCH"])) {
if ($extra_spec["SMART_BRANCH"] == 1) {
$s .= "_JMPZ";
} else if ($extra_spec["SMART_BRANCH"] == 2) {
$s .= "_JMPNZ";
}
}
if (isset($extra_spec["DIM_OBJ"])) {
if ($extra_spec["DIM_OBJ"] == 1) {
$s .= "_DIM";
} else if ($extra_spec["DIM_OBJ"] == 2) {
$s .= "_OBJ";
}
}
if (isset($extra_spec["ISSET"])) {
if ($extra_spec["ISSET"] == 0) {
$s .= "_SET";
} else {
$s .= "_EMPTY";
}
}
return $s;
}
function extra_spec_flags($extra_spec) {
$s = array();
if (isset($extra_spec["OP_DATA"])) {
$s[] = "SPEC_RULE_OP_DATA";
}
if (isset($extra_spec["RETVAL"])) {
$s[] = "SPEC_RULE_RETVAL";
}
if (isset($extra_spec["QUICK_ARG"])) {
$s[] = "SPEC_RULE_QUICK_ARG";
}
if (isset($extra_spec["SMART_BRANCH"])) {
$s[] = "SPEC_RULE_SMART_BRANCH";
}
if (isset($extra_spec["DIM_OBJ"])) {
$s[] = "SPEC_RULE_DIM_OBJ";
}
if (isset($extra_spec["COMMUTATIVE"])) {
$s[] = "SPEC_RULE_COMMUTATIVE";
}
if (isset($extra_spec["ISSET"])) {
$s[] = "SPEC_RULE_ISSET";
}
return $s;
}
function extra_spec_handler($dsc) {
global $op_types_ex;
if (!isset($dsc["spec"])) {
return array(array());
}
$specs = $dsc["spec"];
if (isset($specs["OP_DATA"])) {
$op_data_specs = $specs["OP_DATA"];
$specs["OP_DATA"] = array();
foreach($op_types_ex as $op_data) {
if (isset($dsc["spec"]["OP_DATA"][$op_data])) {
$specs["OP_DATA"][] = $op_data;
}
}
}
$f = function($specs) use (&$f) {
$spec = key($specs);
$top = array_shift($specs);
if ($specs) {
$next = $f($specs);
} else {
$next = array(array());
}
$ret = array();
foreach ($next as $existing) {
foreach ($top as $mode) {
$ret[] = array($spec => $mode) + $existing;
}
}
return $ret;
};
return $f($specs);
}
function read_order_file($fn) {
$f = fopen($fn, "r");
if (!is_resource($f)) {
return false;
}
$order = [];
while (!feof($f)) {
$op = trim(fgets($f));
if ($op !== "") {
$order[$op] = null;
}
}
fclose($f);
return $order;
}
// Generates all opcode handlers and helpers (specialized or unspecilaized)
function gen_executor_code($f, $spec, $kind, $prolog, &$switch_labels = array()) {
global $list, $opcodes, $helpers, $op_types_ex, $gen_order;
if ($kind == ZEND_VM_KIND_HYBRID && file_exists(__DIR__ . "/zend_vm_order.txt")) {
$gen_order = read_order_file(__DIR__ . "/zend_vm_order.txt");
} else {
$gen_order = null;
}
if ($spec) {
// Produce specialized executor
$op1t = $op_types_ex;
// for each op1.op_type
foreach($op1t as $op1) {
$op2t = $op_types_ex;
// for each op2.op_type
foreach($op2t as $op2) {
// for each handlers in helpers in original order
foreach ($list as $lineno => $dsc) {
if (isset($dsc["handler"])) {
$num = $dsc["handler"];
foreach (extra_spec_handler($opcodes[$num]) as $extra_spec) {
// Check if handler accepts such types of operands (op1 and op2)
if (isset($opcodes[$num]["op1"][$op1]) &&
isset($opcodes[$num]["op2"][$op2])) {
// Generate handler code
gen_handler($f, 1, $kind, $opcodes[$num]["op"], $op1, $op2, isset($opcodes[$num]["use"]), $opcodes[$num]["code"], $lineno, $opcodes[$num], $extra_spec, $switch_labels);
}
}
} else if (isset($dsc["helper"])) {
$num = $dsc["helper"];
foreach (extra_spec_handler($helpers[$num]) as $extra_spec) {
// Check if handler accepts such types of operands (op1 and op2)
if (isset($helpers[$num]["op1"][$op1]) &&
isset($helpers[$num]["op2"][$op2])) {
// Generate helper code
gen_helper($f, 1, $kind, $num, $op1, $op2, $helpers[$num]["param"], $helpers[$num]["code"], $lineno, $helpers[$num]["inline"], $helpers[$num]["cold"], $helpers[$num]["hot"], $extra_spec);
}
}
} else {
var_dump($dsc);
die("??? $kind:$num\n");
}
}
}
}
} else {
// Produce unspecialized executor
// for each handlers in helpers in original order
foreach ($list as $lineno => $dsc) {
if (isset($dsc["handler"])) {
$num = $dsc["handler"];
// Generate handler code
if ($num < 256) {
gen_handler($f, 0, $kind, $opcodes[$num]["op"], "ANY", "ANY", isset($opcodes[$num]["use"]), $opcodes[$num]["code"], $lineno, $opcodes[$num]);
}
} else if (isset($dsc["helper"])) {
$num = $dsc["helper"];
// Generate helper code
gen_helper($f, 0, $kind, $num, "ANY", "ANY", $helpers[$num]["param"], $helpers[$num]["code"], $lineno, $helpers[$num]["inline"], $helpers[$num]["cold"], $helpers[$num]["hot"]);
} else {
var_dump($dsc);
die("??? $kind:$num\n");
}
}
}
if (is_array($gen_order)) {
foreach ($gen_order as $txt) {
if ($txt !== null) {
out($f, $txt);
}
}
}
if (ZEND_VM_LINES) {
// Reset #line directives
out_line($f);
}
// Generate handler for undefined opcodes
switch ($kind) {
case ZEND_VM_KIND_CALL:
gen_null_handler($f);
break;
case ZEND_VM_KIND_SWITCH:
out($f,"default:\n");
out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);\n");
out($f,"\tZEND_VM_NEXT_OPCODE(); /* Never reached */\n");
break;
case ZEND_VM_KIND_GOTO:
out($f,"ZEND_NULL_LABEL:\n");
out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);\n");
out($f,"\tZEND_VM_NEXT_OPCODE(); /* Never reached */\n");
break;
case ZEND_VM_KIND_HYBRID:
out($f,"\t\t\tHYBRID_CASE(HYBRID_HALT):\n");
out($f,"\t\t\t\texecute_data = orig_execute_data;\n");
out($f,"\t\t\t\topline = orig_opline;\n");
out($f,"\t\t\t\treturn;\n");
out($f,"\t\t\tHYBRID_DEFAULT:\n");
out($f,"\t\t\t\tVM_TRACE(ZEND_NULL)\n");
out($f,"\t\t\t\tZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n");
out($f,"\t\t\t\tHYBRID_BREAK(); /* Never reached */\n");
break;
}
}
function skip_blanks($f, $prolog, $epilog) {
if (trim($prolog) != "" || trim($epilog) != "") {
out($f, $prolog.$epilog);
}
}
// Generates executor from skeleton file and definition (specialized or unspecialized)
function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) {
global $params, $skeleton_file, $line_no;
$switch_labels = array();
$lineno = 0;
foreach ($skl as $line) {
// Skeleton file contains special markers in form %NAME% those are
// substituted by custom code
if (preg_match("/(.*)[{][%]([A-Z_]*)[%][}](.*)/", $line, $m)) {
switch ($m[2]) {
case "DEFINES":
out($f,"#define SPEC_START_MASK 0x0000ffff\n");
out($f,"#define SPEC_EXTRA_MASK 0xfffc0000\n");
out($f,"#define SPEC_RULE_OP1 0x00010000\n");
out($f,"#define SPEC_RULE_OP2 0x00020000\n");
out($f,"#define SPEC_RULE_OP_DATA 0x00040000\n");
out($f,"#define SPEC_RULE_RETVAL 0x00080000\n");
out($f,"#define SPEC_RULE_QUICK_ARG 0x00100000\n");
out($f,"#define SPEC_RULE_SMART_BRANCH 0x00200000\n");
out($f,"#define SPEC_RULE_DIM_OBJ 0x00400000\n");
out($f,"#define SPEC_RULE_COMMUTATIVE 0x00800000\n");
out($f,"#define SPEC_RULE_ISSET 0x01000000\n");
out($f,"\n");
out($f,"static const uint32_t *zend_spec_handlers;\n");
out($f,"static const void * const *zend_opcode_handlers;\n");
out($f,"static int zend_handlers_count;\n");
if ($kind == ZEND_VM_KIND_HYBRID) {
out($f,"#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)\n");
out($f,"static const void * const * zend_opcode_handler_funcs;\n");
out($f,"static zend_op hybrid_halt_op;\n");
out($f,"#endif\n");
}
out($f,"#if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC\n");
out($f,"static const void *zend_vm_get_opcode_handler(zend_uchar opcode, const zend_op* op);\n");
out($f,"#endif\n\n");
if ($kind == ZEND_VM_KIND_HYBRID) {
out($f,"#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)\n");
out($f,"static const void *zend_vm_get_opcode_handler_func(zend_uchar opcode, const zend_op* op);\n");
out($f,"#else\n");
out($f,"# define zend_vm_get_opcode_handler_func zend_vm_get_opcode_handler\n");
out($f,"#endif\n\n");
}
out($f,"#ifndef VM_TRACE\n");
out($f,"# define VM_TRACE(op)\n");
out($f,"#endif\n");
out($f,"#ifndef VM_TRACE_START\n");
out($f,"# define VM_TRACE_START()\n");
out($f,"#endif\n");
out($f,"#ifndef VM_TRACE_END\n");
out($f,"# define VM_TRACE_END()\n");
out($f,"#endif\n");
switch ($kind) {
case ZEND_VM_KIND_HYBRID:
out($f,"#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)\n");
out($f,"#define HYBRID_NEXT() goto *(void**)(OPLINE->handler)\n");
out($f,"#define HYBRID_SWITCH() HYBRID_NEXT();\n");
out($f,"#define HYBRID_CASE(op) op ## _LABEL\n");
out($f,"#define HYBRID_BREAK() HYBRID_NEXT()\n");
out($f,"#define HYBRID_DEFAULT ZEND_NULL_LABEL\n");
out($f,"#endif\n");
case ZEND_VM_KIND_CALL:
out($f,"\n");
out($f,"#ifdef ZEND_VM_FP_GLOBAL_REG\n");
out($f,"# define ZEND_OPCODE_HANDLER_ARGS void\n");
out($f,"# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU\n");
out($f,"# define ZEND_OPCODE_HANDLER_ARGS_DC\n");
out($f,"# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC\n");
out($f,"#else\n");
out($f,"# define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data\n");
out($f,"# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data\n");
out($f,"# define ZEND_OPCODE_HANDLER_ARGS_DC , ZEND_OPCODE_HANDLER_ARGS\n");
out($f,"# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC , ZEND_OPCODE_HANDLER_ARGS_PASSTHRU\n");
out($f,"#endif\n");
out($f,"\n");
out($f,"#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)\n");
out($f,"# define ZEND_OPCODE_HANDLER_RET void\n");
out($f,"# define ZEND_VM_TAIL_CALL(call) call; return\n");
out($f,"# ifdef ZEND_VM_TAIL_CALL_DISPATCH\n");
out($f,"# define ZEND_VM_CONTINUE() ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); return\n");
out($f,"# else\n");
out($f,"# define ZEND_VM_CONTINUE() return\n");
out($f,"# endif\n");
if ($kind == ZEND_VM_KIND_HYBRID) {
out($f,"# if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)\n");
out($f,"# define ZEND_VM_RETURN() opline = &hybrid_halt_op; return\n");
out($f,"# define ZEND_VM_HOT zend_always_inline ZEND_COLD ZEND_OPT_SIZE\n");
out($f,"# define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE\n");
out($f,"# else\n");
out($f,"# define ZEND_VM_RETURN() opline = NULL; return\n");
out($f,"# define ZEND_VM_HOT\n");
out($f,"# define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE\n");
out($f,"# endif\n");
} else {
out($f,"# define ZEND_VM_RETURN() opline = NULL; return\n");
out($f,"# define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE\n");
}
out($f,"#else\n");
out($f,"# define ZEND_OPCODE_HANDLER_RET int\n");
out($f,"# define ZEND_VM_TAIL_CALL(call) return call\n");
out($f,"# define ZEND_VM_CONTINUE() return 0\n");
out($f,"# define ZEND_VM_RETURN() return -1\n");
if ($kind == ZEND_VM_KIND_HYBRID) {
out($f,"# define ZEND_VM_HOT\n");
out($f,"# define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE\n");
}
out($f,"#endif\n");
out($f,"\n");
out($f,"typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_HANDLER_ARGS);\n");
out($f,"\n");
out($f,"#undef OPLINE\n");
out($f,"#undef DCL_OPLINE\n");
out($f,"#undef USE_OPLINE\n");
out($f,"#undef LOAD_OPLINE\n");
out($f,"#undef LOAD_OPLINE_EX\n");
out($f,"#undef SAVE_OPLINE\n");
out($f,"#define DCL_OPLINE\n");
out($f,"#ifdef ZEND_VM_IP_GLOBAL_REG\n");
out($f,"# define OPLINE opline\n");
out($f,"# define USE_OPLINE\n");
out($f,"# define LOAD_OPLINE() opline = EX(opline)\n");
out($f,"# define LOAD_NEXT_OPLINE() opline = EX(opline) + 1\n");
out($f,"# define SAVE_OPLINE() EX(opline) = opline\n");
out($f,"#else\n");
out($f,"# define OPLINE EX(opline)\n");
out($f,"# define USE_OPLINE const zend_op *opline = EX(opline);\n");
out($f,"# define LOAD_OPLINE()\n");
out($f,"# define LOAD_NEXT_OPLINE() ZEND_VM_INC_OPCODE()\n");
out($f,"# define SAVE_OPLINE()\n");
out($f,"#endif\n");
out($f,"#undef HANDLE_EXCEPTION\n");
out($f,"#undef HANDLE_EXCEPTION_LEAVE\n");
out($f,"#define HANDLE_EXCEPTION() LOAD_OPLINE(); ZEND_VM_CONTINUE()\n");
out($f,"#define HANDLE_EXCEPTION_LEAVE() LOAD_OPLINE(); ZEND_VM_LEAVE()\n");
out($f,"#if defined(ZEND_VM_FP_GLOBAL_REG)\n");
out($f,"# define ZEND_VM_ENTER_EX() ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE()\n");
out($f,"# define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX()\n");
out($f,"# define ZEND_VM_LEAVE() ZEND_VM_CONTINUE()\n");
out($f,"#elif defined(ZEND_VM_IP_GLOBAL_REG)\n");
out($f,"# define ZEND_VM_ENTER_EX() return 1\n");
out($f,"# define ZEND_VM_ENTER() opline = EG(current_execute_data)->opline; ZEND_VM_ENTER_EX()\n");
out($f,"# define ZEND_VM_LEAVE() return 2\n");
out($f,"#else\n");
out($f,"# define ZEND_VM_ENTER_EX() return 1\n");
out($f,"# define ZEND_VM_ENTER() return 1\n");
out($f,"# define ZEND_VM_LEAVE() return 2\n");
out($f,"#endif\n");
out($f,"#define ZEND_VM_INTERRUPT() ZEND_VM_TAIL_CALL(zend_interrupt_helper".($spec?"_SPEC":"")."(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n");
out($f,"#define ZEND_VM_LOOP_INTERRUPT() zend_interrupt_helper".($spec?"_SPEC":"")."(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n");
if ($kind == ZEND_VM_KIND_HYBRID) {
out($f,"#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler_func(opcode, opline))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n");
} else {
out($f,"#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler(opcode, opline))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n");
}
out($f,"\n");
out($f,"static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper".($spec?"_SPEC":"")."(ZEND_OPCODE_HANDLER_ARGS);\n");
out($f,"static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS);\n");
out($f,"\n");
break;
case ZEND_VM_KIND_SWITCH:
out($f,"\n");
out($f,"#undef OPLINE\n");
out($f,"#undef DCL_OPLINE\n");
out($f,"#undef USE_OPLINE\n");
out($f,"#undef LOAD_OPLINE\n");
out($f,"#undef LOAD_NEXT_OPLINE\n");
out($f,"#undef SAVE_OPLINE\n");
out($f,"#define OPLINE opline\n");
out($f,"#ifdef ZEND_VM_IP_GLOBAL_REG\n");
out($f,"# define DCL_OPLINE register const zend_op *opline __asm__(ZEND_VM_IP_GLOBAL_REG);\n");
out($f,"#else\n");
out($f,"# define DCL_OPLINE const zend_op *opline;\n");
out($f,"#endif\n");
out($f,"#define USE_OPLINE\n");
out($f,"#define LOAD_OPLINE() opline = EX(opline)\n");
out($f,"#define LOAD_NEXT_OPLINE() opline = EX(opline) + 1\n");
out($f,"#define SAVE_OPLINE() EX(opline) = opline\n");
out($f,"#undef HANDLE_EXCEPTION\n");
out($f,"#undef HANDLE_EXCEPTION_LEAVE\n");
out($f,"#define HANDLE_EXCEPTION() LOAD_OPLINE(); ZEND_VM_CONTINUE()\n");
out($f,"#define HANDLE_EXCEPTION_LEAVE() LOAD_OPLINE(); ZEND_VM_LEAVE()\n");
out($f,"#define ZEND_VM_CONTINUE() goto zend_vm_continue\n");
out($f,"#define ZEND_VM_RETURN() return\n");
out($f,"#define ZEND_VM_ENTER_EX() ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE()\n");
out($f,"#define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX()\n");
out($f,"#define ZEND_VM_LEAVE() ZEND_VM_CONTINUE()\n");
out($f,"#define ZEND_VM_INTERRUPT() goto zend_interrupt_helper".($spec?"_SPEC":"").";\n");
out($f,"#define ZEND_VM_LOOP_INTERRUPT() goto zend_interrupt_helper".($spec?"_SPEC":"").";\n");
out($f,"#define ZEND_VM_DISPATCH(opcode, opline) dispatch_handler = zend_vm_get_opcode_handler(opcode, opline); goto zend_vm_dispatch;\n");
out($f,"\n");
break;
case ZEND_VM_KIND_GOTO:
out($f,"\n");
out($f,"#undef OPLINE\n");
out($f,"#undef DCL_OPLINE\n");
out($f,"#undef USE_OPLINE\n");
out($f,"#undef LOAD_OPLINE\n");
out($f,"#undef LOAD_NEXT_OPLINE\n");
out($f,"#undef SAVE_OPLINE\n");
out($f,"#define OPLINE opline\n");
out($f,"#ifdef ZEND_VM_IP_GLOBAL_REG\n");
out($f,"# define DCL_OPLINE register const zend_op *opline __asm__(ZEND_VM_IP_GLOBAL_REG);\n");
out($f,"#else\n");
out($f,"# define DCL_OPLINE const zend_op *opline;\n");
out($f,"#endif\n");
out($f,"#define USE_OPLINE\n");
out($f,"#define LOAD_OPLINE() opline = EX(opline)\n");
out($f,"#define LOAD_NEXT_OPLINE() opline = EX(opline) + 1\n");
out($f,"#define SAVE_OPLINE() EX(opline) = opline\n");
out($f,"#undef HANDLE_EXCEPTION\n");
out($f,"#undef HANDLE_EXCEPTION_LEAVE\n");
if (ZEND_VM_SPEC) {
out($f,"#define HANDLE_EXCEPTION() goto ZEND_HANDLE_EXCEPTION_SPEC_LABEL\n");
out($f,"#define HANDLE_EXCEPTION_LEAVE() goto ZEND_HANDLE_EXCEPTION_SPEC_LABEL\n");
} else {
out($f,"#define HANDLE_EXCEPTION() goto ZEND_HANDLE_EXCEPTION_LABEL\n");
out($f,"#define HANDLE_EXCEPTION_LEAVE() goto ZEND_HANDLE_EXCEPTION_LABEL\n");
}
out($f,"#define ZEND_VM_CONTINUE() goto *(void**)(OPLINE->handler)\n");
out(