Analyse der Variablen des zugrunde liegenden PHP-Kernel-Quellcodes (1)

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

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

其中前部分代码是这样的

   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);

这个#开始的内容并不是注释 只需要大概了解下 以下内容

#空指令，无任何效果
#include开头 -------包含一个源代码文件
#define开头 -------定义宏
#undef开头 -------取消已定义的宏
#if开头 -------如果给定条件为真，则编译下面代码
#ifdef开头 -------如果宏已经定义，则编译下面代码
#ifnde开头 -------f如果宏没有定义，则编译下面代码
#elif开头 -------如果前面的#if给定条件不为真，当前条件为真，则编译下面代码
#endif开头 -------结束一个#if……#else条件编译块
#error开头 -------停止编译并显示错误信息

其实就是头文件 无实际寓意 比如#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 };

这部分是 变量 的核心 代码

C语言结构体（Struct）从本质上讲是一种自定义的数据类型，只不过这种数据类型比较复杂，是由 int、char、float 等基本类型组成的。你可以认为结构体是一种聚合类型。在实际开发中，我们可以将一组类型不同的、但是用来描述同一件事物的变量放到结构体中。例如，在校学生有姓名、年龄、身高、成绩等属性，学了结构体后，我们就不需要再定义多个变量了，将它们都放到结构体中即可。 有点类似于 PHP里的对象？

结构体里面用;进行 分割 每个子变量

可以看出来 _zval_struct 结构体 包括三个变量部分 (以单下划线（_）表明是标准库的变量

双下划线（__） 开头表明是编译器的变量)

分别为 value u1 u2

(你要这样 理解 197行中 zend_value value; 这行代码中 zend_value是变量类型 value 是名字 )

结构体里第一个值类型名为 zend_value 这应该不是一个变量 我们搜一下

/zend_value

代码在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;

联合体 / 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;

lval 和 dval 分别为 整型和 浮点型 剩下的 为* 开头的 指针

什么是指针？

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：

type *var-name;

在这里，type 是指针的基类型，它必须是一个有效的 C 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

  int    *ip;    /* 一个整型的指针 
 double *dp;    /* 一个 double 型的指针 
 float  *fp;    /* 一个浮点型的指针
  char   *ch;    /* 一个字符型的指针

所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个代表内存地址的长的十六进制数。

不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。指针占用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;

其实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;

所以 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!