Dieser Artikel stellt Ihnen „Analyse von Variablen im zugrunde liegenden PHP-Kernel-Quellcode (1)“ vor. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.
Empfohlene Artikel: „Analyse von Variablen im zugrunde liegenden PHP-Kernel-Quellcode (2) zend_string“ „Analyse von Variablen im zugrunde liegenden PHP-Kernel-Quellcode (3)“
Vorerst die wichtigsten Elemente Für die Forschung zum zugrunde liegenden Kernel von PHP sind:Variable Array-Speicherverwaltung SAPI-Objekt virtuelle Maschine
PHP-Variablen umfassen 20 Typen, daher kann es einfacher sein, mit Variablen zu beginnen, um andere Elemente zu verstehen
Vier grundlegende Merkmale von PHP-Variablen:
1. Variablenbenennung
In Bezug auf die Variablenbenennung übernimmt PHP den Syntaxstil von Perl. Variablen beginnen mit einem Dollarzeichen, gefolgt vom Variablennamen. Ein gültiger Variablenname beginnt mit einem Buchstaben oder einem Unterstrich, gefolgt von einer beliebigen Anzahl von Buchstaben, Zahlen oder Unterstrichen. Gemäß dem normalen regulären Ausdruck wird er wie folgt ausgedrückt: '^[a-zA-Z_x80-xff][a-zA-Z0-9_x80-xff]*$'
Hinweis: $this ist eine spezielle Variable, It kann nicht zugewiesen werden
Variablen werden standardmäßig immer nach Wert zugewiesen. Das heißt, wenn der Wert eines Ausdrucks einer Variablen zugewiesen wird, wird der Wert des gesamten ursprünglichen Ausdrucks der Zielvariablen zugewiesen. Dies bedeutet, dass sich beispielsweise die Änderung des Werts einer Variablen, während der Wert einer Variablen einer anderen Variablen zugewiesen ist, nicht auf die andere Variable auswirkt. Diese Art der Zuweisungsoperation wird in zukünftigen Artikeln ausführlich erläutert und umfasst hauptsächlich Zeiger und Copy-on-Write. PHP bietet auch eine andere Möglichkeit, Variablen Werte zuzuweisen: Referenzzuweisung. Das bedeutet, dass die neue Variable einfach auf die ursprüngliche Variable verweist (mit anderen Worten „Aliase“ oder „zeigt auf“). Das Ändern der neuen Variablen wirkt sich auf die ursprüngliche Variable aus und umgekehrt. Um die Referenzzuweisung zu verwenden, fügen Sie einfach ein &-Symbol vor der zuzuweisenden Variablen (Quellvariable) hinzu (die Variablenzuweisung wird später ausführlicher besprochen).
PHP unterstützt auch zusammengesetzte Variablen, auch Variablenvariablen genannt. Das heißt, eine Variable wie $$a wird zweimal interpretiert. Dies bringt sehr flexible und dynamische Funktionen in PHP. Der Variablenname einer Variablen kann dynamisch festgelegt und verwendet werden. Eine normale Variable wird durch die Deklaration festgelegt.
Arrays mit veränderlichen Variablen
Um veränderbare Variablennamen für Arrays verwenden zu können, müssen Sie ein Mehrdeutigkeitsproblem lösen. Das heißt, wenn Sie $$a[1] schreiben, muss der Parser verstehen, ob $a[1] als Variable behandelt werden soll oder ob sich $$a als Variable [1] auf diese Variable bezieht. Index. Die Syntax zum Auflösen dieser Mehrdeutigkeit lautet: Verwenden Sie im ersten Fall ${$a[1]}, im zweiten Fall ${$a}[1]. Auf Klassenattribute kann auch über variable Attributnamen zugegriffen werden. Variableneigenschaftsnamen werden aus dem Zugriffsbereich der Variablen übernommen, in der der Aufruf erfolgte. Wenn Ihr Ausdruck beispielsweise so lautet: $foo->$bar, sucht die Laufzeitumgebung im lokalen Variablenbereich nach der Variablen $bar und ihr Wert wird als Eigenschaftsname des $foo-Objekts verwendet. Es kann auch verwendet werden, wenn $bar ein Array ist.
Variablenvariablennamen können nicht für superglobale Array-Variablen in PHP-Funktionen und -Klassen verwendet werden. Auch die Variable $this ist eine spezielle Variable, die nicht dynamisch benannt werden kann.
2. Art der Variablen
In vielen statischen Sprachen werden Variablen angegeben, wenn sie während der Ausführung des Programms geändert werden. PHP ist eine schwach typisierte Sprache kann ihm jede Art von Wert geben. Was ist die Low-Level-Speicherstruktur von Variablen in PHP selbst? Wie implementiert man ein schwaches Typsystem? Und wie werden diese Typen ineinander umgewandelt? Dies wird der Hauptanalyseinhalt dieses Artikels sein. Wenn Sie den zugrunde liegenden PHP-Quellcode genau verstehen möchten, müssen Sie das PHP-Quellcodepaket herunterladen
Ich habe das PHP-Quellcodepaket in der Docker-Umgebung heruntergeladen und gcc gcc-c++ und andere Umgebungen für die anschließende Codeverfolgung installiert Debuggen.
[root@2890cf458ee2 cui-php]# ls
php-7.4.15 php-7.4.15.tar.gz
[root@2890cf458ee2 cui-php]#
[root@2890cf458ee2 cui-php]# cd php-7.4.15
[root@2890cf458ee2 php-7.4.15]# ls
CODING_STANDARDS.md Makefile.objects UPGRADING.INTERNALS buildconf configure.ac main tests
CONTRIBUTING.md NEWS Zend buildconf.bat docs modules tmp-php.ini
EXTENSIONS README.REDIST.BINS appveyor config.log ext pear travis
LICENSE README.md azure config.nice include run-tests.php win32
Makefile TSRM azure-pipelines.yml config.status libs sapi
Makefile.fragments UPGRADING build configure libtool scripts
Nach dem Login kopieren
Hier muss über die Verzeichnisstruktur des PHP-Quellcodes gesprochen werden
Zend: das Implementierungsverzeichnis der Zend-Engine. Einschließlich lexikalischer und syntaktischer Analyse, OPCODE und Bereitstellung einer Sprachlaufzeitumgebung.
TSRM: Thread-sicherer Ressourcenmanager.
Build: Platzieren Sie einige Dateien im Zusammenhang mit der Quellcode-Kompilierung.
ext: Offizielles Erweiterungsverzeichnis. Einschließlich der Implementierung von Array-Serien, PDO-Serien, SPL-Serien und anderen Funktionen.
main: implementiert die Grundfunktionen von PHP. Enthält tatsächlich die wichtigsten PHP-Makros und -Definitionen.
pear: PHP-Erweiterung und Anwendungs-Repository.
sapi: Code für verschiedene Server-Abstraktionsschichten. Zum Beispiel die Schnittstellen mod_php, cgi, fastcgi, fpm und andere von Apache.
tests: Eine Sammlung von PHP-Testskripten.
scripts: Skriptverzeichnis unter Linux.
win32: Einige Implementierungen beziehen sich auf die Windows-Plattform.
PHP-Variablen sind in der Datei zend_types.h im Zend-Verzeichnis definiert.
Wir wechseln in das Zend-Verzeichnis. lo .o.h, im Gegensatz zu PHP Es gibt nur ein .php-Format
Ich werde zunächst die Dateitypen und Suffixe in der C-Sprache vorstellen
c-Datei: Hauptsächlich befindet sich der Originalcode jedes Moduls in der C-Datei.
h文件：每个c文件都跟着一个h文件，h文件的作用是放着c文件中函数的声明，结构体的定义，宏的定义等。
o文件：目标文件。每个文件经过编译都会形成一个目标文件（二进制文件），多个目标文件链接后才能形成可执行文件。
o文件如何形成： gcc -c a.c (gcc 以后会用到 再说)
.so文件
.so文件就不一样了,它不是简单的.o文件打了一个包，它是一个ELF格式的文件，也就是linux的可执行文件。
.so文件可以用于多个进程的共享使用（位置无关的才行），所以又叫共享库文件。程序在使用它的时候，会在运行时把它映射到自己进程空间的某一处，其不在使用它的程序中。
.lo文件 libtool生成的文件，被libtool用来生成共享库的. libtool隐藏了PIC的flag的复杂性，而采用了分离的库对象文件，以“.lo”代替“.o”结尾。在不需要共享库的系统上，这些库文件等同于标准的目标文件
所有以 我们只需要看 .h 和.c就行了 其他的 文件我们想看也看不懂
其中变量的结构体定义和宏定义 在 zend_types.h 中
至于什么是结构体 什么是宏 一会再讲
[root@2890cf458ee2 Zend]# vim zend_types.h
Nach dem Login kopieren
其中前部分代码是这样的
1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 2.00 of the Zend license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.zend.com/license/2_00.txt. |
11 | If you did not receive a copy of the Zend license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@zend.com so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Andi Gutmans <andi@php.net> |
16 | Zeev Suraski <zeev@php.net> |
17 | Dmitry Stogov <dmitry@php.net> |
18 | Xinchen Hui <xinchen.h@zend.com> |
19 +----------------------------------------------------------------------+
20 */
21
22 #ifndef ZEND_TYPES_H
23 #define ZEND_TYPES_H
24
25 #include "zend_portability.h"
26 #include "zend_long.h"
27
28 #ifdef __SSE2__
29 # include <mmintrin.h>
30 # include <emmintrin.h>
31 #endif
32
33 #ifdef WORDS_BIGENDIAN
34 # define ZEND_ENDIAN_LOHI(lo, hi) hi; lo;
35 # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) hi; mi; lo;
36 # define ZEND_ENDIAN_LOHI_4(a, b, c, d) d; c; b; a;
37 # define ZEND_ENDIAN_LOHI_C(lo, hi) hi, lo
38 # define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi) hi, mi, lo,
39 # define ZEND_ENDIAN_LOHI_C_4(a, b, c, d) d, c, b, a
40 #else
41 # define ZEND_ENDIAN_LOHI(lo, hi) lo; hi;
42 # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) lo; mi; hi;
43 # define ZEND_ENDIAN_LOHI_4(a, b, c, d) a; b; c; d;
44 # define ZEND_ENDIAN_LOHI_C(lo, hi) lo, hi
45 # define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi) lo, mi, hi,
46 # define ZEND_ENDIAN_LOHI_C_4(a, b, c, d) a, b, c, d
47 #endif
48
49 typedef unsigned char zend_bool;
50 typedef unsigned char zend_uchar;
51
52 typedef enum {
53 SUCCESS = 0,
54 FAILURE = -1, /* this MUST stay a negative number, or it may affect functions! */
55 } ZEND_RESULT_CODE;
56
57 #ifdef ZEND_ENABLE_ZVAL_LONG64
58 # ifdef ZEND_WIN32
59 # define ZEND_SIZE_MAX _UI64_MAX
60 # else
61 # define ZEND_SIZE_MAX SIZE_MAX
62 # endif
63 #else
64 # if defined(ZEND_WIN32)
65 # define ZEND_SIZE_MAX _UI32_MAX
66 # else
67 # define ZEND_SIZE_MAX SIZE_MAX
68 # endif
69 #endif
70
71 typedef intptr_t zend_intptr_t;
72 typedef uintptr_t zend_uintptr_t;
73
74 #ifdef ZTS
75 #define ZEND_TLS static TSRM_TLS
76 #define ZEND_EXT_TLS TSRM_TLS
77 #else
78 #define ZEND_TLS static
79 #define ZEND_EXT_TLS
80 #endif
81
82 typedef struct _zend_object_handlers zend_object_handlers;
83 typedef struct _zend_class_entry zend_class_entry;
84 typedef union _zend_function zend_function;
85 typedef struct _zend_execute_data zend_execute_data;
86
87 typedef struct _zval_struct zval;
88
89 typedef struct _zend_refcounted zend_refcounted;
90 typedef struct _zend_string zend_string;
91 typedef struct _zend_array zend_array;
92 typedef struct _zend_object zend_object;
93 typedef struct _zend_resource zend_resource;
94 typedef struct _zend_reference zend_reference;
95 typedef struct _zend_ast_ref zend_ast_ref;
96 typedef struct _zend_ast zend_ast;
97
98 typedef int (*compare_func_t)(const void *, const void *);
99 typedef void (*swap_func_t)(void *, void *);
100 typedef void (*sort_func_t)(void *, size_t, size_t, compare_func_t, swap_func_t);
101 typedef void (*dtor_func_t)(zval *pDest);
102 typedef void (*copy_ctor_func_t)(zval *pElement);Nach dem Login kopieren
这个#开始的内容并不是注释 只需要大概了解下 以下内容
#空指令，无任何效果
#include开头 -------包含一个源代码文件
#define开头 -------定义宏
#undef开头 -------取消已定义的宏
#if开头 -------如果给定条件为真，则编译下面代码
#ifdef开头 -------如果宏已经定义，则编译下面代码
#ifnde开头 -------f如果宏没有定义，则编译下面代码
#elif开头 -------如果前面的#if给定条件不为真，当前条件为真，则编译下面代码
#endif开头 -------结束一个#if……#else条件编译块
#error开头 -------停止编译并显示错误信息
Nach dem Login kopieren
其实就是头文件 无实际寓意 比如#ifdef WORDS_BIGENDIAN 这是大小端的 判断
196 struct _zval_struct {
197 zend_value value; /* value */
198 union {
199 struct {
200 ZEND_ENDIAN_LOHI_3(
201 zend_uchar type, /* active type */
202 zend_uchar type_flags,
203 union {
204 uint16_t extra; /* not further specified */
205 } u)
206 } v;
207 uint32_t type_info;
208 } u1;
209 union {
210 uint32_t next; /* hash collision chain */
211 uint32_t cache_slot; /* cache slot (for RECV_INIT) */
212 uint32_t opline_num; /* opline number (for FAST_CALL) */
213 uint32_t lineno; /* line number (for ast nodes) */
214 uint32_t num_args; /* arguments number for EX(This) */
215 uint32_t fe_pos; /* foreach position */
216 uint32_t fe_iter_idx; /* foreach iterator index */
217 uint32_t access_flags; /* class constant access flags */
218 uint32_t property_guard; /* single property guard */
219 uint32_t constant_flags; /* constant flags */
220 uint32_t extra; /* not further specified */
221 } u2;
222 };Nach dem Login kopieren
这部分是 变量 的核心 代码
C语言结构体（Struct）从本质上讲是一种自定义的数据类型，只不过这种数据类型比较复杂，是由 int、char、float 等基本类型组成的。你可以认为结构体是一种聚合类型。在实际开发中，我们可以将一组类型不同的、但是用来描述同一件事物的变量放到结构体中。例如，在校学生有姓名、年龄、身高、成绩等属性，学了结构体后，我们就不需要再定义多个变量了，将它们都放到结构体中即可。 有点类似于 PHP里的对象？
结构体里面用;进行 分割 每个子变量
可以看出来 _zval_struct 结构体 包括三个变量部分 (以单下划线（_）表明是标准库的变量
双下划线（__） 开头表明是编译器的变量)
分别为 value u1 u2
(你要这样 理解 197行中 zend_value value; 这行代码中 zend_value是变量类型 value 是名字 )
结构体里第一个值类型名为 zend_value 这应该不是一个变量 我们搜一下
/zend_value
Nach dem Login kopieren
代码在176处定义了 zend_value
176 typedef union _zend_value {
177 zend_long lval; /* long value */
178 double dval; /* double value */
179 zend_refcounted *counted;
180 zend_string *str;
181 zend_array *arr;
182 zend_object *obj;
183 zend_resource *res;
184 zend_reference *ref;
185 zend_ast_ref *ast;
186 zval *zv;
187 void *ptr;
188 zend_class_entry *ce;
189 zend_function *func;
190 struct {
191 uint32_t w1;
192 uint32_t w2;
193 } ww;
194 } zend_value;Nach dem Login kopieren
联合体 / union
union使用方法和struct非常相似，唯一的不同是struct变量所占内存长度是各成员的内存之和，而union内存长度则是占内存最大的成员的长度，也就是说union的几个成员变量是共用一块内存的。
简单点来说就是
假如
struct a里面 包含 变量a1 内存占用为1 a2 内存占用为2 那么 struct a 总占用内存为1+2=3
union b里面 包含 变量b1 内存占用为1 b2 内存占用为2 那么 union b 总占用内存为2
继续看 zend_value
zend_long lval; //整型
double dval; //浮点型
zend_refcounted *counted; //获取不同类型结构的gc头部的指针
zend_string *str; //string字符串 的指针
zend_array *arr; //数组指针
zend_object *obj; //object 对象指针
zend_resource *res; ///资源类型指针
zend_reference *ref; //引用类型指针 比如你通过&$c 定义的
zend_ast_ref *ast; // ast 指针 线程安全 相关的 内核使用的
zval *zv; // 指向另外一个zval的指针 内核使用的
void *ptr; //指针 ，通用类型 内核使用的
zend_class_entry *ce; //类 ，内核使用的
zend_function *func; // 函数 ，内核使用的
struct {
uint32_t w1;//自己定义的。 无符号的32位整数
uint32_t w2;//同上
} ww;Nach dem Login kopieren
lval 和 dval 分别为 整型和 浮点型 剩下的 为* 开头的 指针
什么是指针？
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：
type *var-name;
Nach dem Login kopieren
在这里，type 是指针的基类型，它必须是一个有效的 C 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：
int *ip; /* 一个整型的指针
double *dp; /* 一个 double 型的指针
float *fp; /* 一个浮点型的指针
char *ch; /* 一个字符型的指针
Nach dem Login kopieren
所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个代表内存地址的长的十六进制数。
不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。指针占用8个字节
所以value 联合体需要的内存是 8 个字节
继续看u1
union {
struct {
//这是个宏 c语言里面 这种全部都是大写的 变量大部分是宏
ZEND_ENDIAN_LOHI_3(
///变量的类型
zend_uchar type,
//类型掩码，每个类型会有不同的属性 内存管理会用到
zend_uchar type_flags,
//这个不知道是干嘛的 估计是预留以后拓展？
union {
uint16_t extra; /* not further specified */
} u)
} v;
//一个无符号的整型 记录 变量类型的
uint32_t type_info;
} u1;Nach dem Login kopieren
其实v 里面就是一个宏 (你可以理解为PHP里面的构造方法 )是为了兼容大小字节序，小字节序就是下面的顺序 大字节序是下面的4个顺序翻转
type_info是用来记录变量的类型 占用4个字节 每个字节对于v中一个成员
所以 u1占用 4个字节 加上 value 8个字节 4+8=12个字节
value 本来应该占 8 个字节，但是由于内存对齐，哪怕只增加一个字节，实际上也是占用 16 个字节（使用一个字节就意味着需要额外的 8 个字节）。但是显然我们并不需要 8 个字节来存储一个 type 字段，所以我们在 u1 的后面增加了了一个名为 u2 的联合体。默认情况下是用不到的，需要使用的时候可以用来存储 4 个字节的数据。这个联合体可以满足不同场景下的需求。
什么是内存对齐？
将每一个数据的起始位置，在内存的对其位置处。
为什么要内存对齐？
无论如何，为了提高程序的性能，数据结构（尤其是栈）应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；然而，对齐的内存访问仅需要一次访问。
这个u2 是扩展用的 一般不会用到
比如 next 在散列表里解决哈希冲突会用到 （现在给你说hash冲突你会懵)
再比如 fe_pos 会在 foreach遍历时候用到
union {
uint32_t next; /* hash collision chain */
uint32_t cache_slot; /* cache slot (for RECV_INIT) */
uint32_t opline_num; /* opline number (for FAST_CALL) */
uint32_t lineno; /* line number (for ast nodes) */
uint32_t num_args; /* arguments number for EX(This) */
uint32_t fe_pos; /* foreach position */
uint32_t fe_iter_idx; /* foreach iterator index */
uint32_t access_flags; /* class constant access flags */
uint32_t property_guard; /* single property guard */
uint32_t constant_flags; /* constant flags */
uint32_t extra; /* not further specified */
} u2;Nach dem Login kopieren
所以 PHP7 以上的 zval_struct 占用16个字节 非常小了!
▏本文经原作者PHP崔雪峰同意，发布在php中文网，原文地址：https://zhuanlan.zhihu.com/p/352507796
Das obige ist der detaillierte Inhalt vonAnalyse der Variablen des zugrunde liegenden PHP-Kernel-Quellcodes (1). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
