PHP 中的操作符重载

1. 操作符重载

操作符重载是一种语法糖,它在 C++、Python、Kotlin 等编程语言中被广泛使用。这一特性有助于我们写出更加整洁、表述力更强的代码,尤其是当我们对某些对象进行数学操作时。

例如,当我们在 PHP 中使用一个 Complex 类,我们往往更希望这样写:

$a = new Complex(1.1, 2.2);$b = new Complex(1.2, 2.3);$c = $a * $b / ($a + $b);

而不是这样:

$c = $a->mul($b)->div($a->add($b));

尽管这个 RFC 提出了要在 PHP 中实现这一特性,然而截至目前,这一提议并未被实施。幸运的是,我们可以通过在 PHP 扩展中编写一些简单的逻辑来实现操作符重载,而无需修改 PHP 本身的源码。PECL operator 扩展做的就是这样一件事情(注意,该扩展的发布版本比较旧,想要 PHP7 支持需要看 git master 分支)。

本文中,我们将讨论在一个 PHP 扩展中实现操作符重载的相关细节。我们假定读者具备 C/C++ 的编程语言基础,并且对 PHP 的 Zend 实现有初步的了解。

2. PHP 的操作码

在一个 PHP 脚本可以在 Zend VM 中运行之前,它首先会被编译为一系列操作码。与机器码类似,一个 PHP 操作码包含指令、操作数等,其存储在结构体 zend_op 中。

struct _zend_op {const void *handler; // 操作码处理函数的指针 znode_op op1; // 第一个操作数 znode_op op2; // 第二个操作数 znode_op result; // 执行结果 uint32_t extended_value; // 与该操作码相关的额外信息 uint32_t lineno; // 操作码所在行数 zend_uchar opcode; // 操作码指令 zend_uchar op1_type; // 第一个操作数的类型 zend_uchar op2_type; // 第二个操作数的类型 zend_uchar result_type; // 执行结果的类型};

2.1 操作数

操作数之于操作码,如同参数之于函数。结构体 zend_op 的操作数成员存储了其所指向的对象的偏移量或指针,在 znode_op 中被定义。由于操作数有多种不同类型(我们后面会讨论),因此用一个联合体定义。

typedef union _znode_op { uint32_t constant; uint32_t var; uint32_t num; uint32_t opline_num;#if ZEND_USE_ABS_JMP_ADDR zend_op *jmp_addr;#else uint32_t jmp_offset;#endif#if ZEND_USE_ABS_CONST_ADDR zval *zv;#endif} znode_op;

正如 zend_compile.h 中所述:

On 64-bit systems, less optimal but more compact VM code leads to better performance. So on 32-bit systems we use absolute addresses for jump targets and constants, but on 64-bit systems relative 32-bit offsets.

在 64 位系统中,宏 ZEND_USE_ABS_JMP_ADDR 和 ZEND_USE_ABS_CONST_ADDR 被定义为 0, 因此 znode_op 永远是 32 位大小。

2.2 操作指令

指令码用于指示 Zend VM 应该对操作数进行什么样的操作。在 zend_vm_opcodes.h 中可以看到所有的指令码定义。

PHP 源码中的操作符会被编译为对应的指令码。借助 phpdbg 或类似调试工具,我们可以分析编译后的操作码。如,PHP 代码 $c = $a + $b 会被编译为:

ADD $a, $b, ~0 # "+" 操作符ASSIGN $c, ~0 # "=" 操作符

可以看到,+ 操作符对应指令 ZEND_ADD$a 和 $b 是操作码的两个操作数。操作结果被存储在临时变量 ~0 中,并在下一行的赋值指令中被赋值给 $c

然而,并非所有操作符都有对应的指令码。如代码 $c = $a > -$b 会被编译为:

MUL $b, -1, ~0 # 转换为乘法操作,乘以 -1IS_SMALLER ~0, $a, ~1 # 调换操作符位置,并转换为小于比较ASSIGN $c, ~1

在之后的章节,我们会对这种情况进行进一步说明。

2.3 操作数类型

结构体 zend_op 的 op1_typeop2_typeresult_type 成员分别存储了第一个操作数、第二个操作数和执行结果的操作数类型。其可能的值如下:

#define IS_UNUSED 0#define IS_CONST (1<<0)#define IS_TMP_VAR (1<<1)#define IS_VAR (1<<2)#define IS_CV (1<<3) // Compiled variable
  • 如果操作数不被使用,则其类型为 IS_UNUSED.
  • 如果操作数是一个字面量 , 则其类型为 IS_CONST.
  • 如果操作数是一个由表达式返回临时变量 , 则其类型为 IS_TMP_VAR.
  • 如果操作数是一个在编译期被确定的变量,则其类型为 IS_CV.
  • 如果操作数是一个由表达式返回的在编译期被确定的变量,则其类型为 IS_VAR.

通过使用调试工具,可以有助于我们理解操作数的类型。如以下 PHP 代码:

$a = 1;$a + 1;$b = $a + 1;$a += 1;$c = $b = $a += 1;

会被编译为:

 # (op1 op2 result) typeASSIGN $a, 1 # CV CONST UNUSEDADD $a, 1, ~1 # CV CONST TMP_VARFREE ~1 # TMP_VAR UNUSED UNUSEDADD $a, 1, ~2 # CV CONST TMP_VARASSIGN $b, ~2 # CV TMP_VAR UNUSEDASSIGN_ADD $a, 1 # CV CONST UNUSEDASSIGN_ADD $a, 1, @5 # CV CONST VARASSIGN $b, @5, @6 # CV VAR VARASSIGN $c, @6 # CV VAR UNUSED

可以看出,编译期确定的变量 $a$b 是 IS_CV,字面量 1 是 IS_CONST,表达式产生的临时变量 ~1~2 是 TMP_VAR@5@6 虽然对应 $a$b,但它们是由表达式返回的,因此是 IS_VAR

同时,我们也发现,对于赋值指令,若其执行结果未被使用,则不会返回结果,而非赋值指令永远会返回结果,即使其未被使用。这是因为赋值指令的运算结果会被赋值给第一个操作数,当其未被使用时,不需要额外的指令去释放内存。在后面的章节我们会进一步讨论这一细节。

3. 操作码处理函数

操作码处理函数的职能是根据给定的指令和操作数执行对应的操作,就像 CPU 执行机器码一样。通过调用如下的 Zend API,我们可以用自定义的函数来替代 Zend VM 内置的操作码处理函数:

ZEND_API int zend_set_user_opcode_handler( zend_uchar opcode, user_opcode_handler_t handler);

其中 handler 参数是自定义的操作码处理函数的指针,opcode 参数是我们想要替代的指令。想要取消设定自定义操作码处理函数,向 handler 参数传递 nullptr 即可。每当操作码被执行时,Zend VM 会调用与其指令码相对应的自定义函数(如果它存在)。

函数指针 user_opcode_handler_t 定义如下:

typedef int (*user_opcode_handler_t) (zend_execute_data *execute_data);

操作码处理函数接受 execute_data 指针作为参数,并返回一个整型,其值为下述之一,代表该函数执行完成后进行的下一步操作。

#define ZEND_USER_OPCODE_CONTINUE 0#define ZEND_USER_OPCODE_RETURN 1#define ZEND_USER_OPCODE_DISPATCH 2#define ZEND_USER_OPCODE_ENTER 3#define ZEND_USER_OPCODE_LEAVE 4

在多数情况下,我们只会用到如下所描述的其中两个返回值:

  • ZEND_USER_OPCODE_CONTINUE 表示该操作码已经执行完成,应该继续执行下一行指令。
  • ZEND_USER_OPCODE_DISPATCH 表示该操作码并没有被执行,应先转为使用内置操作码处理函数去执行,再执行下一行指令。

3.1 实现操作码处理函数

我们用 C++ 定义一个普适性的操作码处理函数模版,如下所示。其中,handler 参数包含处理操作码的具体业务逻辑,它可以为一个函数指针、lambda 表达式或仿函数,接受三个 zval 指针作为参数,分别为两个操作数和执行结果。

template <typename F>int op_handler(zend_execute_data *execute_data, F handler){// 在这里做一些初始化操作if (!handler(op1, op2, result)) {return ZEND_USER_OPCODE_DISPATCH;}// 在这里做一些后续操作return ZEND_USER_OPCODE_CONTINUE;}

在函数的开始,我们先进行一些初始化操作。首先,从 execute_data 中获取到当前执行的操作码,并从操作码中获取到各个操作数所对应的 zval

const zend_op *opline = EX(opline);zend_free_op free_op1, free_op2;zval *op1 = zend_get_zval_ptr(opline, opline->op1_type, &opline->op1, execute_data, &free_op1, 0);zval *op2 = zend_get_zval_ptr(opline, opline->op2_type, &opline->op2, execute_data, &free_op2, 0);zval *result = opline->result_type ? EX_VAR(opline->result.var) : nullptr;

操作数可能是指向其他 zval 的引用,即 zend_reference。我们往往需要先对其解引用。

if (EXPECTED(op1)) {ZVAL_DEREF(op1);}if (op2) {ZVAL_DEREF(op2);}

现在,我们可以像之前所描述的那样调用 handler

若操作数是临时变量,当操作码处理函数执行完成后,我们需要先释放它们。最后,将 execute_data->opline 指向下一行操作码。

if (free_op2) {zval_ptr_dtor_nogc(free_op2);}if (free_op1) {zval_ptr_dtor_nogc(free_op1);}EX(opline) = opline + 1;

现在,我们就可以根据需要,注册自定义的操作码处理函数。

int add_handler(zend_execute_data *execute_data){return op_handler(execute_data, [] (auto zv1, auto zv2, auto rv) {if (/* 是否要在这里重载 "+" 操作符?*/) {// 重载的具体实现return true;}return false;});}PHP_MINIT_FUNCTION(my_extension){// 一般情况下,我们在扩展被载入时注册自定义操作码处理函数zend_set_user_opcode_handler(ZEND_ADD, add_handler);}

4. 操作符重载的实现细节

我们现已知道,通过自定义的操作码处理函数,可以实现操作符重载。下面我们将讨论一些实现细节,从而帮助大家减少在开发过程中的踩坑。

4.1 二元操作符

语法指令码
$a + $bZEND_ADD
$a - $bZEND_SUB
$a * $bZEND_MUL
$a / $bZEND_DIV
$a % $bZEND_MOD
$a ** $bZEND_POW
$a << $bZEND_SL
$a >> $bZEND_SR
$a . $bZEND_CONCAT
$a  $bZEND_BW_OR
$a & $bZEND_BW_AND
$a ^ $bZEND_BW_XOR
$a === $bZEND_IS_IDENTICAL
$a !== $bZEND_IS_NOT_IDENTICAL
$a == $bZEND_IS_EQUAL
$a != $bZEND_IS_NOT_EQUAL
$a < $bZEND_IS_SMALLER
$a <= $bZEND_IS_SMALLER_OR_EQUAL
$a xor $bZEND_BOOL_XOR
$a <=> $bZEND_SPACESHIP

二元操作符接受两个操作数,永远有返回值,而且允许修改操作数(当然如果尝试修改字面量或临时变量,是毫无意义的)。

注意,正如我们在 2.2 中所述,> 和 >= 操作符是没有对应的指令码的。尽管在绝大多数情况下 $a > $b 和 $b < $a 是完全等价的,但也有例外,如 PECL operator 扩展,需要区分这两个操作符,并调用 __is_smaller() 或 __is_greater() 这两个魔术方法之一。

PECL operator 扩展提出了一种方法,即利用 zend_op 的 extended_value 成员区分 > 和 <。但这个 hack 是在解析语法树时做的,没有提供 API 可供我们用自定义方法去替换,需要修改 PHP 的源码并重新编译 PHP。此外,这个做法很可能会影响其在未来 PHP 版本中的兼容性。

这种情况下,建议采用类似如下所示的解决方案:

int is_smaller_handler(zend_execute_data *execute_data) {return op_handler(execute_data, [] (auto zv1, auto zv2, auto rv) {if (Z_TYPE_P(zv1) == IS_OBJECT) {if (__zobj_has_method(Z_OBJ_P(zv1), "__is_smaller")) {// 在这里调用 `$zv1->__is_smaller($zv2)`.return true;}} else if (Z_TYPE_P(zv2) == IS_OBJECT) {if (__zobj_has_method(Z_OBJ_P(zv2), "__is_greater")) {// 在这里调用 `$zv2->__is_greater($zv1)`.return true;}}return false;});}

4.2 二元赋值操作符

语法指令码
$a += $bZEND_ASSIGN_ADD
$a -= $bZEND_ASSIGN_SUB
$a *= $bZEND_ASSIGN_MUL
$a /= $bZEND_ASSIGN_DIV
$a %= $bZEND_ASSIGN_MOD
$a **= $bZEND_ASSIGN_POW
$a <<= $bZEND_ASSIGN_SL
$a >>= $bZEND_ASSIGN_SR
$a .= $bZEND_ASSIGN_CONCAT
$a= $bZEND_ASSIGN_BW_OR
$a &= $bZEND_ASSIGN_BW_AND
$a ^= $bZEND_ASSIGN_BW_XOR
$a = $bZEND_ASSIGN
$a =& $bZEND_ASSIGN_REF

二元赋值操作符与一般的二元操作符类似,区别在于当返回值不被使用(opline->result_type == IS_UNUSED)的时候,不要在操作码处理函数中对其赋值,否则可能会引起错误。

一般来说,二元赋值操作符对应的操作码执行完成后,要将执行结果赋值给第一个操作数。但这并不是必须的,而且 Zend VM 不会帮我们做这件事。

代码示例:

int assign_add_handler(zend_execute_data *execute_data) {return op_handler(execute_data, [] (auto zv1, auto zv2, auto rv) {if (Z_TYPE_P(zv1) == IS_OBJECT) {// 在这里处理 "+" 操作符__update_value(zv1, add_result);if (rv != nullptr) {ZVAL_COPY(rv, zv1);}return true;}return false;});}

4.3 一元操作符

语法指令码
~$aZEND_BW_NOT
!$aZEND_BOOL_NOT

一元操作符仅接受一个操作数(opline->op1),永远有返回值,而且允许修改操作数。

正如我们在 2.2 所述,一元操作符 -$a 和 +$a 没有对应的指令码,因为它们被编译为操作数与 -1 and 1的乘法。如果在我们想要实现的逻辑中,-$a 与 $a * (-1) 不等价,则需要在 ZEND_MUL 的处理函数中加入一些额外的逻辑。

注意,在 PHP 7.3 和低于 7.3 的版本之间,存在如下的兼容性问题,即 $a * (-1) 和 (-1) * $a 的区别:

PHP 版本语法指令码操作数 1操作数 2
7.3-$a or +$aZEND_MUL$a-1 or 1
7.1, 7.2-$a or +$aZEND_MUL-1 or 1$a

如下是在 ZEND_MUL 处理函数中同时实现重载 -$a 和 $a * $b 两个操作符的例子:

int mul_handler(zend_execute_data *execute_data) {return op_handler(execute_data, [] (auto zv1, auto zv2, auto rv) {if (Z_TYPE_P(zv1) == IS_OBJECT) {#if PHP_VERISON_ID >= 70300if (Z_TYPE_P(zv2) == IS_LONG && Z_LVAL_P(zv2) == -1) {// 在这里处理 `-$zv1`return true;}#endif// 在这里处理 `$zv1 * $zv2`return true;} else if (Z_TYPE_P(zv2) == IS_OBJECT) {#if PHP_VERISON_ID < 70300if (Z_TYPE_P(zv1) == IS_LONG && Z_LVAL_P(zv1) == -1) {// 在这里处理 `-$zv2`return true;}#endif// 在这里处理 `$zv1 * $zv2`return true;}return false;});}

4.4 一元赋值操作符

语法指令码
++$aZEND_PRE_INC
$a++ZEND_POST_INC
--$aZEND_PRE_DEC
$a--ZEND_POST_DEC

一元赋值操作符有两种。第一种是后缀自增 / 自减操作符,其行为与非赋值的一元操作符相同。第二种是前缀自增 / 自减操作符,它与二元赋值操作符的行为相同。

这不难理解,因为在常规的使用场景下,后缀自增 / 自减操作符需要将自己的初始值保存在一个临时变量中返回,而前缀自增 / 自减操作符先执行自增 / 自减操作再返回,无需释放临时变量。

例如,以下 PHP 代码:

$a = 0;$a++;++$a;$b = ++$a;

会被编译为:

ASSIGN $a, 0POST_INC $a, , ~1FREE ~1PRE_INC $aPRE_INC $a, , @3ASSIGN $b, @3

4.5 无法重载操作符的情况

尝试编译以下代码:

$a = 2 + 3 * (7 + 9);$b = 'foo' . 'bar';

我们会得到:

ASSIGN $a, 50ASSIGN $b, "foobar"

可以看出,变量 $a 和 $b 的值在编译期已被确定,运行时没有数学运算和字符串拼接操作。对于任何一个只包含字面量和操作符的表达式,这种情况都是成立的。编译器会识别出它,并调用 zend_compile.h 中定义的函数 zend_const_expr_to_zval() 对其进行求值。在这个函数中,操作码处理函数是通过 get_binary_op()get_unary_op() 等函数获取的。内置操作码处理函数的指针被硬编码在其中,因此,即使我们实现了自定义处理函数,它们也不会在这里被调用。

5. 补充

  • 如果读者需要一个完整可运行的例子,可以参考下面这个复数类的实现。它是我正在开发的一个 PHP 扩展的一部分。
    • complex.hh,包含了和复数类相关的操作码处理函数的具体实现。
    • complex.cc,复数类的实现。
    • operators.cc,包含操作符重载的实现。
    • 002-complex-operators.phpt,有关操作符重载的测试样例。
  • 可自定义的操作码处理函数是一个强大的功能,它的用途远远不限于操作符重载。因为我们可以 hook 几乎所有在 Zend VM 中执行的指令,包括函数调用等。
    • 假设我们想要实现一个 profiler,我们可能会考虑对 ZEND_INIT_FCALL 和 ZEND_RETURN 注册处理函数。
  • 事物均有两面性。由于额外的函数调用开销,使用自定义的操作码处理函数会降低 PHP 程序整体的执行性能。
    • 当一个处理函数中包含了大量分支判断,最后还很可能返回一个 ZEND_USER_OPCODE_DISPATCH 时,你可能需要考虑一下,这个函数是否有实现的必要。
 
登入/注册
卧槽~你还有脸回来
没有账号? 忘记密码?