成长共勉 2020-04-07
我以前对于 C 语言的印象是有很强的确定性,而 PHP 在执行的时候会被翻译为 C 语言执行,所以一直很好奇 PHP 怎么调用底层函数。
换句话说就是已知函数名字的情况下如何调用 C 语言中对应名字的函数?
解决这个问题前,首先根据过往的经验做出假设,然后再去验证。
之前在写《用 C 语言实现面向对象》的时候,就意识到使用 void 指针实现很多功能,包括指向任意的函数。接着在写《PHP 数组底层实现》的时候,了解了 HashTable 的实现,即在 C 语言层面通过字符串 key 找到任意类型值。
现在把两者结合起来,是否就能解决以上问题了?比如说把函数名作为 HashTable 的 key,函数指针作为 HashTable 的 value,这样就可以通过函数名获取函数指针来调用函数了。
接下来通过查看 PHP 的源码来看这个假设与真实情况有多少差距。
总体分为三个步骤:
注:这篇博客的源码对应的版本是 PHP 7.4.4 。
首先要找到 C 语言层调用函数的地方。怎么找?
经常使用 PHP 的同学看到前面的问题描述很容易联想到 PHP 中的一个传入函数名及其参数就可以调用函数的函数 call_user_func()
。可以从这里入手。
怎么找到 call_user_func()
在 PHP 源码中的位置?这就要根据 PHP 源码的规律来找了。
当然也可以直接全代码搜索,只是比较慢。
PHP 源码里面在定义一个 PHP 函数的时候会用 PHP_FUNCTION(函数名)
,所以只要找到 PHP_FUNCTION(call_user_func)
就可以了。
另外 call_user_func()
不像 array_column()
这种函数有特定前缀 array_
,所以属于比较基础的函数,而 PHP 的基础函数会放在两个地方:
Zend/zend_buildin_functions.c
;ext/standard/
。ext/standard/array.c
里有 array_column()
之类的函数。在这两个地方搜索就能找到 PHP_FUNCTION(call_user_func)
,如下:
ext/standard/basic_functions.c
PHP_FUNCTION(call_user_func) { // ... if (zend_call_function(&fci, &fci_cache) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { // ... } }
现在我们已经从 PHP 层面进入到 C 语言层面,接下去就是在 C 语言代码里面探索了。
从上文展示位于 ext/standard/basic_functions.c
的 call_user_func()
函数定义可以找到关键点 zend_call_function()
,现在要找到这个函数。
这种以 zend_
开头的函数都在 Zend/
文件夹底下,所以我们要换个目录了。
在 Zend/
文件夹里面随便搜索 zend_call_function
,从搜索结果里面随便挑一个跳转,然后通过 IDE 的功能(ctrl + 鼠标左键)跳转到它定义的地方就可以了。
如果 IDE 能直接跳转就不用在
Zend/
文件夹搜索了,这里是因为 VS Code 没法直接跳转。
注:以下代码中的 // ...
都表示我省略了一部分代码,但我会尽量保持代码结构。
第一遍看代码的时候不需要掌握所有细节,只需要了解整体概念或者前后关系,否则会陷入细节无法自拔。
Zend/zend_execute_API.c
int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) /* {{{ */ { // ... if (!fci_cache || !fci_cache->function_handler) { // ... if (!zend_is_callable_ex(&fci->function_name, fci->object, IS_CALLABLE_CHECK_SILENT, NULL, fci_cache, &error)) { // ... } // ... } func = fci_cache->function_handler; // ... call = zend_vm_stack_push_call_frame(call_info, func, fci->param_count, object_or_called_scope); // ... if (func->type == ZEND_USER_FUNCTION) { // ... } else if (func->type == ZEND_INTERNAL_FUNCTION) { // ... func->internal_function.handler(call, fci->retval); // ... } else { // ... } // ... return SUCCESS; } /* }}} */
这里的关键点在于和函数名以及函数调用相关的词。关键词有:
上面的代码片段中,我把几个有可能的点抽出来了。从这几个点出发,往前追溯参数来源或者查看后面使用它的地方就行了。
如果被这个函数里面大量的
EG(...)
吸引而想知道其内部结构的话,就离结果非常近了。如果没有被其吸引,那也没关系,继续看。
优先深入看哪个呢?根据以前看数组源码的经验, “查找” 这个行为更容易获得信息,于是先看 zend_is_callable_check_func()
。
Zend/zend_API.c
static zend_always_inline int zend_is_callable_check_func(int check_flags, zval *callable, zend_fcall_info_cache *fcc, int strict_class, char **error) /* {{{ */ { // ... if (!ce_org) { // ... /* Check if function with given name exists. * This may be a compound name that includes namespace name */ if (UNEXPECTED(Z_STRVAL_P(callable)[0] == ‘\\‘)) { // ... func = zend_fetch_function(lmname); // ... } // ... } // ... }
zend_fetch_function()
与我们想要的答案有很强的相关性,看它怎么实现的。
Zend/zend_execute.c
ZEND_API zend_function * ZEND_FASTCALL zend_fetch_function(zend_string *name) { zval *zv = zend_hash_find(EG(function_table), name); // ... }
来了来了!在这里就可以看到函数的确存在于 HashTable 里面。而这个 HashTable 通过 EG 获取。
Zend/zend_globals_macros.h
# define EG(v) (executor_globals.v)
再跳转一次。
Zend/zend_compile.c
ZEND_API zend_executor_globals executor_globals;
zend_executor_globals
是一个结构体。
PHP 的源码中,结构体的真实定义会以下划线开头。
于是找 _zend_executor_globals
。
Zend/zend_globals.h
struct _zend_executor_globals { // ... HashTable *function_table; /* function symbol table */ HashTable *class_table; /* class table */ HashTable *zend_constants; /* constants table */ // ... }
到这里就找到存储函数的地方了。验证了函数名作为 key,函数指针作为 value 的可行性。
不过 PHP 并没有把函数指针直接作为 value,而是包装到了 zval 里面,以实现更多功能。从下面这一句就可以看出。
zval *zv = zend_hash_find(EG(function_table), name);
看看 zval 里面有什么。
Zend/zend_types.h
typedef struct _zval_struct zval; struct _zval_struct { zend_value value; /* value */ // ... };
继续:
Zend/zend_types.h
typedef union _zend_value { zend_long lval; /* long value */ double dval; /* double value */ zend_refcounted *counted; zend_string *str; zend_array *arr; zend_object *obj; zend_resource *res; zend_reference *ref; zend_ast_ref *ast; zval *zv; void *ptr; zend_class_entry *ce; zend_function *func; struct { uint32_t w1; uint32_t w2; } ww; } zend_value;
注:这个结构体很重要,我保留了全貌。
看到 zend_function
这个结构体,搜索 _zend_function
。
union _zend_function { // ... zend_internal_function internal_function; };
在 zend_value 联合体中可以看到 zend_internal_function
这个内部函数专用结构体,调用内部函数时用到它。搜索 _zend_internal_function
。
Zend/zend_compile.h
/* zend_internal_function_handler */ typedef void (ZEND_FASTCALL *zif_handler)(INTERNAL_FUNCTION_PARAMETERS); typedef struct _zend_internal_function { /* Common elements */ zend_uchar type; zend_uchar arg_flags[3]; /* bitset of arg_info.pass_by_reference */ uint32_t fn_flags; zend_string* function_name; zend_class_entry *scope; zend_function *prototype; uint32_t num_args; uint32_t required_num_args; zend_internal_arg_info *arg_info; /* END of common elements */ zif_handler handler; struct _zend_module_entry *module; void *reserved[ZEND_MAX_RESERVED_RESOURCES]; } zend_internal_function;
结构体 _zend_internal_function
里面的 handler 成员是 zif_handler
类型。 从前面的定义可以知道 zif_handler
是一个函数指针类型,这就是用来存函数指针的地方。
现在知道函数指针是存放在 handler 里面了,接着就是找到使用它的地方。
此时再回过头看 zend_call_function
这个函数。
Zend/zend_execute_API.c
int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) /* {{{ */ { // ... if (func->type == ZEND_USER_FUNCTION) { // ... } else if (func->type == ZEND_INTERNAL_FUNCTION) { // ... func->internal_function.handler(call, fci->retval); // ... } // ... } /* }}} */
可以看到调用函数的地方:
func->internal_function.handler(call, fci->retval);
handler 的参数固定是两个。这里要结合之前的 PHP_FUNCTION(call_user_func)
来看。
为了将 PHP_FUNCTION(call_user_func)
展开,以下连续列出三个定义:
main/php.h
#define PHP_FUNCTION ZEND_FUNCTION
Zend/zend_API.h
#define ZEND_FN(name) zif_##name #define ZEND_MN(name) zim_##name #define ZEND_NAMED_FUNCTION(name) void ZEND_FASTCALL name(INTERNAL_FUNCTION_PARAMETERS) #define ZEND_FUNCTION(name) ZEND_NAMED_FUNCTION(ZEND_FN(name))
Zend/zend.h
#define INTERNAL_FUNCTION_PARAMETERS zend_execute_data *execute_data, zval *return_value
根据这三个地方的代码展开 PHP_FUNCTION(call_user_func)
可以得到:
void ZEND_FASTCALL call_user_func(zend_execute_data *execute_data, zval *return_value)
再看一次 func->internal_function.handler(call, fci->retval);
。联系起来了!
上文以 PHP_FUNCTION(call_user_func)
作为入口只是其中一种思路。实际上 PHP 在调用函数的时候不是通过 call_user_func
,不然 call_user_func
本身又是如何被调用的呢?
PHP 执行的时候,会在 PHP 虚拟机里面去调用函数。PHP 虚拟机首先会读取 PHP 文件,然后解析为 OPCode (操作码)执行。这里就要借助调试器的力量了。
这里跳过 OPCode 的生成,因为与本次要探索的内容关系不是很大。
开启调试。然后不断往下走,可以找到一个比较接近答案的地方。
Zend/zend_vm_execute.h
ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value) { zend_execute_data *execute_data; // ... i_init_code_execute_data(execute_data, op_array, return_value); zend_execute_ex(execute_data); zend_vm_stack_free_call_frame(execute_data); }
先看 zend_execute_ex
:
Zend/zend_vm_execute.h
// ... # define OPLINE EX(opline) // ... # define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data // ... ZEND_API void execute_ex(zend_execute_data *ex) { DCL_OPLINE // ... zend_execute_data *execute_data = ex; // ... LOAD_OPLINE(); ZEND_VM_LOOP_INTERRUPT_CHECK(); // ... while (1) { // ... int ret; // ... if (UNEXPECTED((ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)) != 0)) { // ... if (EXPECTED(ret > 0)) { execute_data = EG(current_execute_data); ZEND_VM_LOOP_INTERRUPT_CHECK(); } else { // ... return; } // ... } } zend_error_noreturn(E_CORE_ERROR, "Arrived at end of main loop which shouldn‘t happen"); }
又看到了 handler,这里难道就是真正执行函数的地方?
先找到 OPLINE 的真身,根据:
Zend/zend_compile.h
#define EX(element) ((execute_data)->element)
对 OPLINE 展开后,得到 execute_data->opline
。
再根据 execute_ex()
前面的定义对整行展开得到:
if (UNEXPECTED((ret = ((opcode_handler_t)(execute_data->opline)->handler)(execute_data)) != 0))
现在出现四个新问题:
要解决这个问题,得先找到 opline 是哪来的。
回到 Zend/zend_vm_execute.h
的 zend_execute()
:
Zend/zend_vm_execute.h
ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value) { zend_execute_data *execute_data; // ... i_init_code_execute_data(execute_data, op_array, return_value); zend_execute_ex(execute_data); zend_vm_stack_free_call_frame(execute_data); }
在 zend_execute_ex()
前面有个 i_init_code_execute_data()
:
Zend/zend_execute.c
static zend_always_inline void i_init_code_execute_data(zend_execute_data *execute_data, zend_op_array *op_array, zval *return_value) /* {{{ */ { // ... EX(opline) = op_array->opcodes; // ... }
opline 来自于 zend_op_array 的 opcodes ,搜索 _zend_op_array
。
Zend/zend_compile.h
struct _zend_op_array { // ... zend_op *opcodes; // ... };
opcodes 是 zend_op 这种结构体,搜索 _zend_op
。
Zend/zend_compile.h
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; };
到这里就找到了 handler 存储的位置。
注:在
Zend/zend_vm_opcodes.h
可以找到 OPCode 对应的整数,在Zend/zend_vm_opcodes.c
可以找到这些整数和字符串的对应。
由于 handler 是函数指针,可以指向任意函数,所以无法直接定位。于是通过调试执行下面这一句来找一些线索:
Zend/zend_vm_execute.h
ZEND_API void execute_ex(zend_execute_data *ex) { // ... while (1) { // ... if (UNEXPECTED((ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)) != 0)) { // ... } } // ... }
在这一句的位置使用 “jump into”,会跳转到一个函数。这个函数就是 handler 指向的函数了。
由于每次跳到的函数都可能不一样,所以选其中一个来查。
Zend/zend_vm_execute.h
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { // ... }
搜索函数名 ZEND_INIT_FCALL_SPEC_CONST_HANDLER
。
Zend/zend_vm_execute.h
void zend_vm_init(void) { static const void * const labels[] = { // ... ZEND_INIT_FCALL_SPEC_CONST_HANDLER, // ... }; static const uint32_t specs[] = { // ... }; // ... zend_opcode_handlers = labels; zend_handlers_count = sizeof(labels) / sizeof(void*); zend_spec_handlers = specs; // ... }
handler 可以指向 labels 里面包含的所有函数。
上一节列出的 zend_vm_init()
把所有函数都放到了 labels 数组里面,并赋值给了 zend_opcode_handlers ,找找用到它的地方。
Zend/zend_vm_execute.h
static const void* ZEND_FASTCALL zend_vm_get_opcode_handler_ex(uint32_t spec, const zend_op* op) { // ... return zend_opcode_handlers[(spec & SPEC_START_MASK) + offset]; }
如果搜索调用 zend_vm_get_opcode_handler_ex
的代码,那么就很容易找到给 handler 赋值的地方了。
Zend/zend_vm_execute.h
ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler(zend_op* op) { // ... op->handler = zend_vm_get_opcode_handler_ex(zend_spec_handlers[opcode], op); }
把上面举的例子 handler 指向的函数 ZEND_INIT_FCALL_SPEC_CONST_HANDLER
再拿出来。
为了更加明显,此处不省略代码。
Zend/zend_vm_execute.h
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *fname; zval *func; zend_function *fbc; zend_execute_data *call; fbc = CACHED_PTR(opline->result.num); if (UNEXPECTED(fbc == NULL)) { fname = (zval*)RT_CONSTANT(opline, opline->op2); func = zend_hash_find_ex(EG(function_table), Z_STR_P(fname), 1); if (UNEXPECTED(func == NULL)) { ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } call = _zend_vm_stack_push_call_frame_ex( opline->op1.num, ZEND_CALL_NESTED_FUNCTION, fbc, opline->extended_value, NULL); call->prev_execute_data = EX(call); EX(call) = call; ZEND_VM_NEXT_OPCODE(); }
从中看不到执行的地方。找到的 func 也只是被放入 fcb,然后 push 到虚拟机调用栈里面。
注:这里另一个值得注意的地方是
ZEND_VM_NEXT_OPCODE();
。因为最开始的execute_ex
函数(下一节列出了代码)里面只是一个死循环,且没有修改 OPLINE 的指向,而是在这些 handler 函数里面修改。
那真正调用函数的地方在哪呢?
回到最开始的 execute_ex()
。
Zend/zend_vm_execute.h
ZEND_API void execute_ex(zend_execute_data *ex) { DCL_OPLINE // ... zend_execute_data *execute_data = ex; // ... LOAD_OPLINE(); ZEND_VM_LOOP_INTERRUPT_CHECK(); // ... while (1) { // ... int ret; // ... if (UNEXPECTED((ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)) != 0)) { // ... if (EXPECTED(ret > 0)) { execute_data = EG(current_execute_data); ZEND_VM_LOOP_INTERRUPT_CHECK(); } else { // ... return; } // ... } } zend_error_noreturn(E_CORE_ERROR, "Arrived at end of main loop which shouldn‘t happen"); }
通过调试可以知道,如果是一些简单的操作, handler 就会直接处理。比如加减法。但是像函数调用这种,就不会在 handler 这里处理。
那么只能看下面的代码。
只有当 ret 大于 0 的时候会有额外的操作。通过调试可以看到有以下几个大于 0 的情况。
Zend/zend_vm_execute.h
# define ZEND_VM_ENTER_EX() return 1 # define ZEND_VM_ENTER() return 1 # define ZEND_VM_LEAVE() return 2
这个信息没有多大影响。
那么接下来就得看 ZEND_VM_LOOP_INTERRUPT_CHECK();
了。
Zend/zend_execute.c
#define ZEND_VM_LOOP_INTERRUPT_CHECK() do { if (UNEXPECTED(EG(vm_interrupt))) { ZEND_VM_LOOP_INTERRUPT(); } } while (0)
继续:
Zend/zend_vm_execute.h
#define ZEND_VM_LOOP_INTERRUPT() zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
继续:
Zend/zend_vm_execute.h
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) { EG(vm_interrupt) = 0; if (EG(timed_out)) { zend_timeout(0); } else if (zend_interrupt_function) { SAVE_OPLINE(); zend_interrupt_function(execute_data); ZEND_VM_ENTER(); } ZEND_VM_CONTINUE(); }
搜索 zend_interrupt_function
发现它是一个函数指针。那么转成搜索 zend_interrupt_function =
,看看哪个函数的指针传给了它。
这时搜索到了两条线。一条是 ext/pcntl/pcntl.c
,另一条是 win32/signal.c
。
这里选 win32/signal.c
:
win32/signal.c
PHP_WINUTIL_API void php_win32_signal_ctrl_handler_init(void) {/*{{{*/ // ... zend_interrupt_function = php_win32_signal_ctrl_interrupt_function; // ... }/*}}}*/
接着找函数 php_win32_signal_ctrl_interrupt_function
。
win32/signal.c
static void php_win32_signal_ctrl_interrupt_function(zend_execute_data *execute_data) {/*{{{*/ if (IS_UNDEF != Z_TYPE(ctrl_handler)) { zval retval, params[1]; ZVAL_LONG(¶ms[0], ctrl_evt); /* If the function returns, */ call_user_function(NULL, NULL, &ctrl_handler, &retval, 1, params); zval_ptr_dtor(&retval); } if (orig_interrupt_function) { orig_interrupt_function(execute_data); } }/*}}}*/
感觉很接近了。
call_user_function
传了两个 NULL,为了避免理解上有偏差,把它的定义列出来。
Zend/zend_API.h
#define call_user_function(function_table, object, function_name, retval_ptr, param_count, params) _call_user_function_ex(object, function_name, retval_ptr, param_count, params, 1)
继续:
Zend/zend_execute_API.c
int _call_user_function_ex(zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[], int no_separation) /* {{{ */ { zend_fcall_info fci; fci.size = sizeof(fci); fci.object = object ? Z_OBJ_P(object) : NULL; ZVAL_COPY_VALUE(&fci.function_name, function_name); fci.retval = retval_ptr; fci.param_count = param_count; fci.params = params; fci.no_separation = (zend_bool) no_separation; return zend_call_function(&fci, NULL); }
绕了一圈还是绕回来了。又一次见到 zend_call_function
。上文已经分析过这个函数了,不再重复。
本文通过假设 PHP 函数调用方式和查询源码验证,得到了 PHP 底层将 C 语言函数存储到 HashTable 然后通过函数名字找到函数指针来调用这一结论。同时也了解了 PHP 函数执行的大致流程。
虽然了解了也没什么用的样子,但好奇心得到了满足 233
<?php. if (!empty($_POST)) {. $data1 = $_POST["data1"];$data2 = $_POST["data2"];$fuhao = $_POST["fuh