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_type
,op2_type
,result_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 + $b | ZEND_ADD | |
$a - $b | ZEND_SUB | |
$a * $b | ZEND_MUL | |
$a / $b | ZEND_DIV | |
$a % $b | ZEND_MOD | |
$a ** $b | ZEND_POW | |
$a << $b | ZEND_SL | |
$a >> $b | ZEND_SR | |
$a . $b | ZEND_CONCAT | |
$a | $b | ZEND_BW_OR |
$a & $b | ZEND_BW_AND | |
$a ^ $b | ZEND_BW_XOR | |
$a === $b | ZEND_IS_IDENTICAL | |
$a !== $b | ZEND_IS_NOT_IDENTICAL | |
$a == $b | ZEND_IS_EQUAL | |
$a != $b | ZEND_IS_NOT_EQUAL | |
$a < $b | ZEND_IS_SMALLER | |
$a <= $b | ZEND_IS_SMALLER_OR_EQUAL | |
$a xor $b | ZEND_BOOL_XOR | |
$a <=> $b | ZEND_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 += $b | ZEND_ASSIGN_ADD | |
$a -= $b | ZEND_ASSIGN_SUB | |
$a *= $b | ZEND_ASSIGN_MUL | |
$a /= $b | ZEND_ASSIGN_DIV | |
$a %= $b | ZEND_ASSIGN_MOD | |
$a **= $b | ZEND_ASSIGN_POW | |
$a <<= $b | ZEND_ASSIGN_SL | |
$a >>= $b | ZEND_ASSIGN_SR | |
$a .= $b | ZEND_ASSIGN_CONCAT | |
$a | = $b | ZEND_ASSIGN_BW_OR |
$a &= $b | ZEND_ASSIGN_BW_AND | |
$a ^= $b | ZEND_ASSIGN_BW_XOR | |
$a = $b | ZEND_ASSIGN | |
$a =& $b | ZEND_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 一元操作符
语法 | 指令码 |
---|---|
~$a | ZEND_BW_NOT |
!$a | ZEND_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 +$a | ZEND_MUL | $a | -1 or 1 |
7.1, 7.2 | -$a or +$a | ZEND_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 一元赋值操作符
语法 | 指令码 |
---|---|
++$a | ZEND_PRE_INC |
$a++ | ZEND_POST_INC |
--$a | ZEND_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
注册处理函数。
- 假设我们想要实现一个 profiler,我们可能会考虑对
- 事物均有两面性。由于额外的函数调用开销,使用自定义的操作码处理函数会降低 PHP 程序整体的执行性能。
- 当一个处理函数中包含了大量分支判断,最后还很可能返回一个
ZEND_USER_OPCODE_DISPATCH
时,你可能需要考虑一下,这个函数是否有实现的必要。
- 当一个处理函数中包含了大量分支判断,最后还很可能返回一个