PHP7源码分析--流程控制（1. 普通语句跳转）

作者: 拿破仑蛋糕 | 来源:发表于2019-10-22 17:58 被阅读0次

以 if/else 为例，分析普通语句跳转的代码实现：

一、测试代码：

<?php
$a = 2;
if($a == 0)
{
    echo 0;
}
elseif ($a == 1)
{
    echo 1;
}
else
{
    echo 2;
}

二、前面过程跳过，直接在编译的地方打断点 zend_compile，单步调试到源码的第 601 行，

// 文件位置：Zend/zend_language_scanner.l:577
599         zend_file_context_begin(&original_file_context);
(gdb)
600         zend_oparray_context_begin(&original_oparray_context);
(gdb)
601         zend_compile_top_stmt(CG(ast));
(gdb)

s 命令 进入 zend_compile_top_stmt(CG(ast)) 方法，这个方法的作用就是递归AST 抽象语法树，生成对应的op_array，最终调用 zend_compile_stmt。

// 文件位置： Zend/zend_compile.c
void zend_compile_top_stmt(zend_ast *ast) /* {{{ */
{
    if (!ast) {
        return;
    }

    // 递归处理抽象语法树的节点，根据节点的类型
    // 做不同的处理，此处需要处理的是  *ZEND_AST_STMT_LIST* 类型的节点
    if (ast->kind == ZEND_AST_STMT_LIST) {
        zend_ast_list *list = zend_ast_get_list(ast);
        uint32_t i;
        for (i = 0; i < list->children; ++i) {
            zend_compile_top_stmt(list->child[i]);
        }
        return;
    }

    // 根据节点的类型进行相应的编译
    zend_compile_stmt(ast);

    if (ast->kind != ZEND_AST_NAMESPACE && ast->kind != ZEND_AST_HALT_COMPILER) {
        zend_verify_namespace();
    }
    if (ast->kind == ZEND_AST_FUNC_DECL || ast->kind == ZEND_AST_CLASS) {
        CG(zend_lineno) = ((zend_ast_decl *) ast)->end_lineno;
        zend_do_early_binding();
    }
}

zend_compile_stmt(ast)方法：

//文件位置：Zend/zend_compile.c
void zend_compile_stmt(zend_ast *ast) /* {{{ */
{
    ...
    //根据节点不通的类型进行编译
    switch (ast->kind) {
        case ZEND_AST_STMT_LIST:
            zend_compile_stmt_list(ast);
            break;
        case ZEND_AST_GLOBAL:
            zend_compile_global_var(ast);
            break;
            ...
        case ZEND_AST_IF:
            zend_compile_if(ast);
            break;
            ...
}
/* }}} */

从代码中可以看出if相关语句，是通过 zend_compile_if(ast) 方法编译的

//文件位置：Zend/zend_compile.c
void zend_compile_if(zend_ast *ast) /* {{{ */
{
    zend_ast_list *list = zend_ast_get_list(ast);
    uint32_t i;
    uint32_t *jmp_opnums = NULL;

    if (list->children > 1) {
        jmp_opnums = safe_emalloc(sizeof(uint32_t), list->children - 1, 0);//申请一个数组，大小等于 if 分支数，用于存储对应的分支的 opcode 数
    }

    for (i = 0; i < list->children; ++i) {
        zend_ast *elem_ast = list->child[i];
        zend_ast *cond_ast = elem_ast->child[0];  //condition:条件
        zend_ast *stmt_ast = elem_ast->child[1];  //statement:说明（条件为真时，需要执行的语句）

        znode cond_node;
        uint32_t opnum_jmpz;
        if (cond_ast) {
            //编译条件语句
            zend_compile_expr(&cond_node, cond_ast);
            // 编译生成用于跳转的 opcode，
            opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0);
        }

        //编译statement语句
        zend_compile_stmt(stmt_ast);

        if (i != list->children - 1) {
            //编译statement执行完后跳出if的opcode：ZEND_JMP(最后一个分支无需这条opcode)
            jmp_opnums[i] = zend_emit_jump(0);
        }

        if (cond_ast) {
            //设置ZEND_JMPZ跳过opcode数
            zend_update_jump_target_to_next(opnum_jmpz);
        }
    }

    if (list->children > 1) {
        for (i = 0; i < list->children - 1; ++i) {
            zend_update_jump_target_to_next(jmp_opnums[i]);
        }
        efree(jmp_opnums);
    }
}
/* }}} */

好了，到了这里，就可以看出 if 部分的代码是怎么编译的了，代码中关键的部分也有注释，简单说，就是在条件语句和if 条件成立时需要执行的代码之间，添加了 JMP 和JMPZ 跳转语句来控制代码的执行顺序的。

咱们从头把代码撸一遍：
1.首先，申请一个数组，数组的大小为 if 分支语句的数量（测试代码中一共有 3 个分支）
2.遍历语法树，先编译条件语句，然后生成一个用于跳转的 opcode：JMPZ（表示条件不成立时，跳转到一个地址），并返回需要跳过的 opcode 数。需要注意的是，在没有编译statement 语句时，是不知道要跳过多少条 opcode 的，只有编译完了自己分支下的 statement 后，才能知道。
3.编译 statement 语句，编译完之后，在除了最后一个 statement 之外的其他分支的 statement之后，生成另一个用于跳转的 opcode：JMP（表示直接跳转到某个地址），把需要跳过的 opcode 数，保存到步骤 1 中申请的数组中。
4.更新有条件语句的分支需要跳过的 opcode 数，因为没有条件语句的分支，就是最后一个分支，不需要更新。
5.重新遍历所有分支，把每个 JMP 需要跳过的 opcode 数（跳出 if 判断）更新。

三、opcode 和 ast 语法树查看

opcode查看：https://3v4l.org
opcode.png
ast 树查看：https://dooakitestapp.herokuapp.com/phpast/webapp/
image.png

digraph ast {
1 [label = "AST_STMT_LIST"]
2 [label = "AST_ASSIGN"]
1 -> 2;
3 [label = "AST_VAR"]
2 -> 3;
4 [label = "AST_ZVAL\n'a'"]
3 -> 4;
5 [label = "AST_ZVAL\n2"]
2 -> 5;
6 [label = "AST_IF"]
1 -> 6;
7 [label = "AST_IF_ELEM"]
6 -> 7;
8 [label = "AST_BINARY_OP\n[==]"]
7 -> 8;
9 [label = "AST_VAR"]
8 -> 9;
10 [label = "AST_ZVAL\n'a'"]
9 -> 10;
11 [label = "AST_ZVAL\n0"]
8 -> 11;
12 [label = "AST_STMT_LIST"]
7 -> 12;
13 [label = "AST_STMT_LIST"]
12 -> 13;
14 [label = "AST_ECHO"]
13 -> 14;
15 [label = "AST_ZVAL\n0"]
14 -> 15;
16 [label = "AST_IF_ELEM"]
6 -> 16;
17 [label = "AST_BINARY_OP\n[==]"]
16 -> 17;
18 [label = "AST_VAR"]
17 -> 18;
19 [label = "AST_ZVAL\n'a'"]
18 -> 19;
20 [label = "AST_ZVAL\n1"]
17 -> 20;
21 [label = "AST_STMT_LIST"]
16 -> 21;
22 [label = "AST_STMT_LIST"]
21 -> 22;
23 [label = "AST_ECHO"]
22 -> 23;
24 [label = "AST_ZVAL\n1"]
23 -> 24;
25 [label = "AST_IF_ELEM"]
6 -> 25;
uq1 [label = NULL]
25 -> uq1;
26 [label = "AST_STMT_LIST"]
25 -> 26;
27 [label = "AST_STMT_LIST"]
26 -> 27;
28 [label = "AST_ECHO"]
27 -> 28;
29 [label = "AST_ZVAL\n2"]
28 -> 29;
}

四、switch 的编译也是类似的，所以就不具体分析了，我列出源码，opcode 和 ast 大家自己分析一下：

源码

//测试代码：
<?php
$a = 0;
switch($a)
{
    case 0:
        echo 0;
        break;
    case 0:
        echo 0;
        break;
    default:
        echo 3;
}
//文件位置：Zend/zend_compile.c
void zend_compile_switch(zend_ast *ast) /* {{{ */
{
    zend_ast *expr_ast = ast->child[0];
    zend_ast_list *cases = zend_ast_get_list(ast->child[1]);

    uint32_t i;
    zend_bool has_default_case = 0;

    znode expr_node, case_node;
    zend_op *opline;
    uint32_t *jmpnz_opnums, opnum_default_jmp;

    zend_compile_expr(&expr_node, expr_ast);

    zend_begin_loop(ZEND_FREE, &expr_node);

    case_node.op_type = IS_TMP_VAR;
    case_node.u.op.var = get_temporary_variable(CG(active_op_array));

    jmpnz_opnums = safe_emalloc(sizeof(uint32_t), cases->children, 0);
    for (i = 0; i < cases->children; ++i) {
        zend_ast *case_ast = cases->child[i];
        zend_ast *cond_ast = case_ast->child[0];
        znode cond_node;

        if (!cond_ast) {
            if (has_default_case) {
                CG(zend_lineno) = case_ast->lineno;
                zend_error_noreturn(E_COMPILE_ERROR,
                    "Switch statements may only contain one default clause");
            }
            has_default_case = 1;
            continue;
        }

        zend_compile_expr(&cond_node, cond_ast);

        if (expr_node.op_type == IS_CONST
            && Z_TYPE(expr_node.u.constant) == IS_FALSE) {
            jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0);
        } else if (expr_node.op_type == IS_CONST
            && Z_TYPE(expr_node.u.constant) == IS_TRUE) {
            jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, 0);
        } else {
            opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node);
            SET_NODE(opline->result, &case_node);
            if (opline->op1_type == IS_CONST) {
                zval_copy_ctor(CT_CONSTANT(opline->op1));
            }

            jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0);
        }
    }

    opnum_default_jmp = zend_emit_jump(0);

    for (i = 0; i < cases->children; ++i) {
        zend_ast *case_ast = cases->child[i];
        zend_ast *cond_ast = case_ast->child[0];
        zend_ast *stmt_ast = case_ast->child[1];

        if (cond_ast) {
            zend_update_jump_target_to_next(jmpnz_opnums[i]);
        } else {
            zend_update_jump_target_to_next(opnum_default_jmp);
        }

        zend_compile_stmt(stmt_ast);
    }

    if (!has_default_case) {
        zend_update_jump_target_to_next(opnum_default_jmp);
    }

    zend_end_loop(get_next_op_number(CG(active_op_array)), &expr_node);

    if (expr_node.op_type & (IS_VAR|IS_TMP_VAR)) {
        /* don't use emit_op() to prevent automatic live-range construction */
        opline = get_next_op(CG(active_op_array));
        opline->opcode = ZEND_FREE;
        SET_NODE(opline->op1, &expr_node);
        SET_UNUSED(opline->op2);
    } else if (expr_node.op_type == IS_CONST) {
        zval_dtor(&expr_node.u.constant);
    }

    efree(jmpnz_opnums);
}
/* }}} */

说明：
1.这里多了 zend_begin_loop和zend_end_loop 这两个方法，这里先不说，循环语句的源码分析中会说；
2.switch的编译，会先编译完所有的 condition ，然后再编译 statement

2.opcode：

opcode.png

3.ast树：

image.png

digraph ast {
1 [label = "AST_STMT_LIST"]
2 [label = "AST_ASSIGN"]
1 -> 2;
3 [label = "AST_VAR"]
2 -> 3;
4 [label = "AST_ZVAL\n'a'"]
3 -> 4;
5 [label = "AST_ZVAL\n0"]
2 -> 5;
6 [label = "AST_SWITCH"]
1 -> 6;
7 [label = "AST_VAR"]
6 -> 7;
8 [label = "AST_ZVAL\n'a'"]
7 -> 8;
9 [label = "AST_SWITCH_LIST"]
6 -> 9;
10 [label = "AST_SWITCH_CASE"]
9 -> 10;
11 [label = "AST_ZVAL\n0"]
10 -> 11;
12 [label = "AST_STMT_LIST"]
10 -> 12;
13 [label = "AST_STMT_LIST"]
12 -> 13;
14 [label = "AST_ECHO"]
13 -> 14;
15 [label = "AST_ZVAL\n0"]
14 -> 15;
16 [label = "AST_BREAK"]
12 -> 16;
uq1 [label = NULL]
16 -> uq1;
17 [label = "AST_SWITCH_CASE"]
9 -> 17;
18 [label = "AST_ZVAL\n0"]
17 -> 18;
19 [label = "AST_STMT_LIST"]
17 -> 19;
20 [label = "AST_STMT_LIST"]
19 -> 20;
21 [label = "AST_ECHO"]
20 -> 21;
22 [label = "AST_ZVAL\n0"]
21 -> 22;
23 [label = "AST_BREAK"]
19 -> 23;
uq2 [label = NULL]
23 -> uq2;
24 [label = "AST_SWITCH_CASE"]
9 -> 24;
uq3 [label = NULL]
24 -> uq3;
25 [label = "AST_STMT_LIST"]
24 -> 25;
26 [label = "AST_STMT_LIST"]
25 -> 26;
27 [label = "AST_ECHO"]
26 -> 27;
28 [label = "AST_ZVAL\n3"]
27 -> 28;
}

PHP7源码分析--流程控制（1. 普通语句跳转）

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读