zend_compile.h

/*
 +----------------------------------------------------------------------+
 | Zend Engine |
 +----------------------------------------------------------------------+
 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
 +----------------------------------------------------------------------+
 | This source file is subject to version 2.00 of the Zend license, |
 | that is bundled with this package in the file LICENSE, and is |
 | available through the world-wide-web at the following url: |
 | http://www.zend.com/license/2_00.txt. |
 | If you did not receive a copy of the Zend license and are unable to |
 | obtain it through the world-wide-web, please send a note to |
 | license@zend.com so we can mail you a copy immediately. |
 +----------------------------------------------------------------------+
 | Authors: Andi Gutmans <andi@php.net> |
 | Zeev Suraski <zeev@php.net> |
 +----------------------------------------------------------------------+
*/

#ifndefZEND_COMPILE_H
#defineZEND_COMPILE_H

#include"zend_ast.h"
#include"zend_types.h"
#include"zend_map_ptr.h"
#include"zend_alloc.h"

#include<stdarg.h>
#include<stdint.h>

#include"zend_llist.h"
#include"zend_frameless_function.h"
#include"zend_property_hooks.h"

#defineSET_UNUSED(op) do { \
 op ## _type = IS_UNUSED; \
 op.num = (uint32_t) -1; \
} while (0)

#defineMAKE_NOP(opline) do { \
 (opline)->opcode = ZEND_NOP; \
 SET_UNUSED((opline)->op1); \
 SET_UNUSED((opline)->op2); \
 SET_UNUSED((opline)->result); \
} while (0)

#defineRESET_DOC_COMMENT() do { \
 if (CG(doc_comment)) { \
 zend_string_release_ex(CG(doc_comment), 0); \
 CG(doc_comment) = NULL; \
 } \
} while (0)

typedefstruct_zend_op_arrayzend_op_array;
typedefstruct_zend_opzend_op;

/* 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 */
#ifSIZEOF_SIZE_T==4
# defineZEND_USE_ABS_JMP_ADDR 1
# defineZEND_USE_ABS_CONST_ADDR 1
#else
# defineZEND_USE_ABS_JMP_ADDR 0
# defineZEND_USE_ABS_CONST_ADDR 0
#endif

typedefunion_znode_op {
uint32_tconstant;
uint32_tvar;
uint32_tnum;
uint32_topline_num; /* Needs to be signed */
#ifZEND_USE_ABS_JMP_ADDR
zend_op*jmp_addr;
#else
uint32_tjmp_offset;
#endif
#ifZEND_USE_ABS_CONST_ADDR
zval*zv;
#endif
} znode_op;

typedefstruct_znode { /* used only during compilation */
uint8_top_type;
uint8_tflag;
union {
znode_opop;
zvalconstant; /* replaced by literal/zv */
 } u;
} znode;

typedefstruct_zend_ast_znode {
zend_ast_kindkind;
zend_ast_attrattr;
uint32_tlineno;
znodenode;
} zend_ast_znode;

ZEND_APIzend_ast*ZEND_FASTCALLzend_ast_create_znode(znode*node);

staticzend_always_inlineznode*zend_ast_get_znode(zend_ast*ast) {
return&((zend_ast_znode*) ast)->node;
}

typedefstruct_zend_declarables {
zend_longticks;
} zend_declarables;

/* Compilation context that is different for each file, but shared between op arrays. */
typedefstruct_zend_file_context {
zend_declarablesdeclarables;

zend_string*current_namespace;
boolin_namespace;
boolhas_bracketed_namespaces;

HashTable*imports;
HashTable*imports_function;
HashTable*imports_const;

HashTableseen_symbols;
} zend_file_context;

typedefunion_zend_parser_stack_elem {
zend_ast*ast;
zend_string*str;
zend_ulongnum;
unsigned char*ptr;
unsigned char*ident;
} zend_parser_stack_elem;

voidzend_compile_top_stmt(zend_ast*ast);
voidzend_const_expr_to_zval(zval*result, zend_ast**ast_ptr, boolallow_dynamic);

typedefint (*user_opcode_handler_t) (zend_execute_data*execute_data);

struct_zend_op {
constvoid*handler;
znode_opop1;
znode_opop2;
znode_opresult;
uint32_textended_value;
uint32_tlineno;
uint8_topcode; /* Opcodes defined in Zend/zend_vm_opcodes.h */
uint8_top1_type; /* IS_UNUSED, IS_CONST, IS_TMP_VAR, IS_VAR, IS_CV */
uint8_top2_type; /* IS_UNUSED, IS_CONST, IS_TMP_VAR, IS_VAR, IS_CV */
uint8_tresult_type; /* IS_UNUSED, IS_CONST, IS_TMP_VAR, IS_VAR, IS_CV */
#ifdefZEND_VERIFY_TYPE_INFERENCE
uint32_top1_use_type;
uint32_top2_use_type;
uint32_tresult_use_type;
uint32_top1_def_type;
uint32_top2_def_type;
uint32_tresult_def_type;
#endif
};


typedefstruct_zend_brk_cont_element {
intstart;
intcont;
intbrk;
intparent;
boolis_switch;
} zend_brk_cont_element;

typedefstruct_zend_label {
intbrk_cont;
uint32_topline_num;
} zend_label;

typedefstruct_zend_try_catch_element {
uint32_ttry_op;
uint32_tcatch_op; /* ketchup! */
uint32_tfinally_op;
uint32_tfinally_end;
} zend_try_catch_element;

#defineZEND_LIVE_TMPVAR 0
#defineZEND_LIVE_LOOP 1
#defineZEND_LIVE_SILENCE 2
#defineZEND_LIVE_ROPE 3
#defineZEND_LIVE_NEW 4
#defineZEND_LIVE_MASK 7

typedefstruct_zend_live_range {
uint32_tvar; /* low bits are used for variable type (ZEND_LIVE_* macros) */
uint32_tstart;
uint32_tend;
} zend_live_range;

typedefstruct_zend_property_infozend_property_info;

/* Compilation context that is different for each op array. */
typedefstruct_zend_oparray_context {
struct_zend_oparray_context*prev;
zend_op_array*op_array;
uint32_topcodes_size;
intvars_size;
intliterals_size;
uint32_tfast_call_var;
uint32_ttry_catch_offset;
intcurrent_brk_cont;
intlast_brk_cont;
zend_brk_cont_element*brk_cont_array;
HashTable*labels;
zend_string*active_property_info_name;
zend_property_hook_kindactive_property_hook_kind;
boolin_jmp_frameless_branch;
} zend_oparray_context;

/* Class, property and method flags class|meth.|prop.|const*/
/* | | | */
/* Common flags | | | */
/* ============ | | | */
/* | | | */
/* Visibility flags (public < protected < private) | | | */
#defineZEND_ACC_PUBLIC (1 << 0) /* | X | X | X */
#defineZEND_ACC_PROTECTED (1 << 1) /* | X | X | X */
#defineZEND_ACC_PRIVATE (1 << 2) /* | X | X | X */
/* | | | */
/* Property or method overrides private one | | | */
#defineZEND_ACC_CHANGED (1 << 3) /* | X | X | */
/* | | | */
/* Static method or property | | | */
#defineZEND_ACC_STATIC (1 << 4) /* | X | X | */
/* | | | */
/* Final class or method | | | */
#defineZEND_ACC_FINAL (1 << 5) /* X | X | X | X */
/* | | | */
/* Abstract method | | | */
#defineZEND_ACC_ABSTRACT (1 << 6) /* X | X | X | */
#defineZEND_ACC_EXPLICIT_ABSTRACT_CLASS (1 << 6) /* X | | | */
/* | | | */
/* Readonly property | | | */
#defineZEND_ACC_READONLY (1 << 7) /* | | X | */
/* | | | */
/* Immutable op_array and class_entries | | | */
/* (implemented only for lazy loading of op_arrays) | | | */
#defineZEND_ACC_IMMUTABLE (1 << 7) /* X | X | | */
/* | | | */
/* Function has typed arguments / class has typed props | | | */
#defineZEND_ACC_HAS_TYPE_HINTS (1 << 8) /* X | X | | */
/* | | | */
/* Top-level class or function declaration | | | */
#defineZEND_ACC_TOP_LEVEL (1 << 9) /* X | X | | */
/* | | | */
/* op_array or class is preloaded | | | */
#defineZEND_ACC_PRELOADED (1 << 10) /* X | X | | */
/* | | | */
/* Flag to differentiate cases from constants. | | | */
/* Must not conflict with ZEND_ACC_ visibility flags | | | */
/* or IS_CONSTANT_VISITED_MARK | | | */
#defineZEND_CLASS_CONST_IS_CASE (1 << 6) /* | | | X */
/* | | | */
/* Property Flags (unused: 13...) | | | */
/* =========== | | | */
/* | | | */
/* Promoted property / parameter | | | */
#defineZEND_ACC_PROMOTED (1 << 8) /* | | X | */
/* | | | */
/* Virtual property without backing storage | | | */
#defineZEND_ACC_VIRTUAL (1 << 9) /* | | X | */
/* | | | */
/* Asymmetric visibility | | | */
#defineZEND_ACC_PUBLIC_SET (1 << 10) /* | | X | */
#defineZEND_ACC_PROTECTED_SET (1 << 11) /* | | X | */
#defineZEND_ACC_PRIVATE_SET (1 << 12) /* | | X | */
/* | | | */
/* Class Flags (unused: 30,31) | | | */
/* =========== | | | */
/* | | | */
/* Special class types | | | */
#defineZEND_ACC_INTERFACE (1 << 0) /* X | | | */
#defineZEND_ACC_TRAIT (1 << 1) /* X | | | */
#defineZEND_ACC_ANON_CLASS (1 << 2) /* X | | | */
#defineZEND_ACC_ENUM (1 << 28) /* X | | | */
/* | | | */
/* Class linked with parent, interfaces and traits | | | */
#defineZEND_ACC_LINKED (1 << 3) /* X | | | */
/* | | | */
/* Class is abstract, since it is set by any | | | */
/* abstract method | | | */
#defineZEND_ACC_IMPLICIT_ABSTRACT_CLASS (1 << 4) /* X | | | */
/* | | | */
/* Class has magic methods __get/__set/__unset/ | | | */
/* __isset that use guards | | | */
#defineZEND_ACC_USE_GUARDS (1 << 11) /* X | | | */
/* | | | */
/* Class constants updated | | | */
#defineZEND_ACC_CONSTANTS_UPDATED (1 << 12) /* X | | | */
/* | | | */
/* Objects of this class may not have dynamic properties | | | */
#defineZEND_ACC_NO_DYNAMIC_PROPERTIES (1 << 13) /* X | | | */
/* | | | */
/* User class has methods with static variables | | | */
#defineZEND_HAS_STATIC_IN_METHODS (1 << 14) /* X | | | */
/* | | | */
/* Objects of this class may have dynamic properties | | | */
/* without triggering a deprecation warning | | | */
#defineZEND_ACC_ALLOW_DYNAMIC_PROPERTIES (1 << 15) /* X | | | */
/* | | | */
/* Readonly class | | | */
#defineZEND_ACC_READONLY_CLASS (1 << 16) /* X | | | */
/* | | | */
/* Parent class is resolved (CE). | | | */
#defineZEND_ACC_RESOLVED_PARENT (1 << 17) /* X | | | */
/* | | | */
/* Interfaces are resolved (CEs). | | | */
#defineZEND_ACC_RESOLVED_INTERFACES (1 << 18) /* X | | | */
/* | | | */
/* Class has unresolved variance obligations. | | | */
#defineZEND_ACC_UNRESOLVED_VARIANCE (1 << 19) /* X | | | */
/* | | | */
/* Class is linked apart from variance obligations. | | | */
#defineZEND_ACC_NEARLY_LINKED (1 << 20) /* X | | | */
/* Class has readonly props | | | */
#defineZEND_ACC_HAS_READONLY_PROPS (1 << 21) /* X | | | */
/* | | | */
/* stored in opcache (may be partially) | | | */
#defineZEND_ACC_CACHED (1 << 22) /* X | | | */
/* | | | */
/* temporary flag used during delayed variance checks | | | */
#defineZEND_ACC_CACHEABLE (1 << 23) /* X | | | */
/* | | | */
#defineZEND_ACC_HAS_AST_CONSTANTS (1 << 24) /* X | | | */
#defineZEND_ACC_HAS_AST_PROPERTIES (1 << 25) /* X | | | */
#defineZEND_ACC_HAS_AST_STATICS (1 << 26) /* X | | | */
/* | | | */
/* loaded from file cache to process memory | | | */
#defineZEND_ACC_FILE_CACHED (1 << 27) /* X | | | */
/* | | | */
/* Class cannot be serialized or unserialized | | | */
#defineZEND_ACC_NOT_SERIALIZABLE (1 << 29) /* X | | | */
/* | | | */
/* Function Flags (unused: 30) | | | */
/* ============== | | | */
/* | | | */
/* deprecation flag | | | */
#defineZEND_ACC_DEPRECATED (1 << 11) /* | X | | X */
/* | | | */
/* Function returning by reference | | | */
#defineZEND_ACC_RETURN_REFERENCE (1 << 12) /* | X | | */
/* | | | */
/* Function has a return type | | | */
#defineZEND_ACC_HAS_RETURN_TYPE (1 << 13) /* | X | | */
/* | | | */
/* Function with variable number of arguments | | | */
#defineZEND_ACC_VARIADIC (1 << 14) /* | X | | */
/* | | | */
/* op_array has finally blocks (user only) | | | */
#defineZEND_ACC_HAS_FINALLY_BLOCK (1 << 15) /* | X | | */
/* | | | */
/* "main" op_array with | | | */
/* ZEND_DECLARE_CLASS_DELAYED opcodes | | | */
#defineZEND_ACC_EARLY_BINDING (1 << 16) /* | X | | */
/* | | | */
/* closure uses $this | | | */
#defineZEND_ACC_USES_THIS (1 << 17) /* | X | | */
/* | | | */
/* call through user function trampoline. e.g. | | | */
/* __call, __callstatic | | | */
#defineZEND_ACC_CALL_VIA_TRAMPOLINE (1 << 18) /* | X | | */
/* | | | */
/* disable inline caching | | | */
#defineZEND_ACC_NEVER_CACHE (1 << 19) /* | X | | */
/* | | | */
/* op_array is a clone of trait method | | | */
#defineZEND_ACC_TRAIT_CLONE (1 << 20) /* | X | | */
/* | | | */
/* functions is a constructor | | | */
#defineZEND_ACC_CTOR (1 << 21) /* | X | | */
/* | | | */
/* Closure related | | | */
#defineZEND_ACC_CLOSURE (1 << 22) /* | X | | */
#defineZEND_ACC_FAKE_CLOSURE (1 << 23) /* | X | | *//* Same as ZEND_CALL_FAKE_CLOSURE */
/* | | | */
#defineZEND_ACC_GENERATOR (1 << 24) /* | X | | */
/* | | | */
/* function was processed by pass two (user only) | | | */
#defineZEND_ACC_DONE_PASS_TWO (1 << 25) /* | X | | */
/* | | | */
/* internal function is allocated at arena (int only) | | | */
#defineZEND_ACC_ARENA_ALLOCATED (1 << 25) /* | X | | */
/* | | | */
/* run_time_cache allocated on heap (user only) | | | */
#defineZEND_ACC_HEAP_RT_CACHE (1 << 26) /* | X | | */
/* | | | */
/* method flag used by Closure::__invoke() (int only) | | | */
#defineZEND_ACC_USER_ARG_INFO (1 << 26) /* | X | | */
/* | | | */
/* supports opcache compile-time evaluation (funcs) | | | */
#defineZEND_ACC_COMPILE_TIME_EVAL (1 << 27) /* | X | | */
/* | | | */
/* has #[\Override] attribute | | | */
#defineZEND_ACC_OVERRIDE (1 << 28) /* | X | | */
/* | | | */
/* Has IS_PTR operands that needs special cleaning; same | | | */
/* value as ZEND_ACC_OVERRIDE but override is for class | | | */
/* methods and this is for the top level op array | | | */
#defineZEND_ACC_PTR_OPS (1 << 28) /* | X | | */
/* | | | */
/* has #[\NoDiscard] attribute | | | */
#defineZEND_ACC_NODISCARD (1 << 29) /* | X | | */
/* | | | */
/* op_array uses strict mode types | | | */
#defineZEND_ACC_STRICT_TYPES (1U << 31) /* | X | | */

#defineZEND_ACC_PPP_MASK (ZEND_ACC_PUBLIC | ZEND_ACC_PROTECTED | ZEND_ACC_PRIVATE)
#defineZEND_ACC_PPP_SET_MASK (ZEND_ACC_PUBLIC_SET | ZEND_ACC_PROTECTED_SET | ZEND_ACC_PRIVATE_SET)

staticzend_always_inlineuint32_tzend_visibility_to_set_visibility(uint32_tvisibility)
{
switch (visibility) {
caseZEND_ACC_PUBLIC:
returnZEND_ACC_PUBLIC_SET;
caseZEND_ACC_PROTECTED:
returnZEND_ACC_PROTECTED_SET;
caseZEND_ACC_PRIVATE:
returnZEND_ACC_PRIVATE_SET;
EMPTY_SWITCH_DEFAULT_CASE();
 }
}

/* call through internal function handler. e.g. Closure::invoke() */
#defineZEND_ACC_CALL_VIA_HANDLER ZEND_ACC_CALL_VIA_TRAMPOLINE

#defineZEND_ACC_UNINSTANTIABLE ( \
 ZEND_ACC_INTERFACE | \
 ZEND_ACC_TRAIT | \
 ZEND_ACC_IMPLICIT_ABSTRACT_CLASS | \
 ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | \
 ZEND_ACC_ENUM \
)

#defineZEND_SHORT_CIRCUITING_CHAIN_MASK 0x3
#defineZEND_SHORT_CIRCUITING_CHAIN_EXPR 0
#defineZEND_SHORT_CIRCUITING_CHAIN_ISSET 1
#defineZEND_SHORT_CIRCUITING_CHAIN_EMPTY 2

// Must not clash with ZEND_SHORT_CIRCUITING_CHAIN_MASK
#defineZEND_JMP_NULL_BP_VAR_IS 4

char*zend_visibility_string(uint32_tfn_flags);

#defineZEND_PROPERTY_HOOK_COUNT 2
#defineZEND_PROPERTY_HOOK_STRUCT_SIZE (sizeof(zend_function*) * ZEND_PROPERTY_HOOK_COUNT)

/* Stored in zend_property_info.offset, not returned by zend_get_property_offset(). */
#defineZEND_VIRTUAL_PROPERTY_OFFSET ((uint32_t)-1)

zend_property_hook_kindzend_get_property_hook_kind_from_name(zend_string*name);

typedefstruct_zend_property_info {
uint32_toffset; /* property offset for object properties or
 property index for static properties */
uint32_tflags;
zend_string*name;
zend_string*doc_comment;
HashTable*attributes;
zend_class_entry*ce;
zend_typetype;
constzend_property_info*prototype;
zend_function**hooks;
} zend_property_info;

#defineOBJ_PROP(obj, offset) \
 ((zval*)((char*)(obj) + offset))
#defineOBJ_PROP_NUM(obj, num) \
 (&(obj)->properties_table[(num)])
#defineOBJ_PROP_TO_OFFSET(num) \
 ((uint32_t)(XtOffsetOf(zend_object, properties_table) + sizeof(zval) * (num)))
#defineOBJ_PROP_TO_NUM(offset) \
 (((offset) - OBJ_PROP_TO_OFFSET(0)) / sizeof(zval))
#defineOBJ_PROP_SLOT_TO_OFFSET(obj, slot) \
 ((uintptr_t)(slot) - (uintptr_t)(obj))

typedefstruct_zend_class_constant {
zvalvalue; /* flags are stored in u2 */
zend_string*doc_comment;
HashTable*attributes;
zend_class_entry*ce;
zend_typetype;
} zend_class_constant;

#defineZEND_CLASS_CONST_FLAGS(c) Z_CONSTANT_FLAGS((c)->value)

/* arg_info for internal functions */
typedefstruct_zend_internal_arg_info {
constchar*name;
zend_typetype;
constchar*default_value;
} zend_internal_arg_info;

/* arg_info for user functions */
typedefstruct_zend_arg_info {
zend_string*name;
zend_typetype;
zend_string*default_value;
} zend_arg_info;

/* the following structure repeats the layout of zend_internal_arg_info,
 * but its fields have different meaning. It's used as the first element of
 * arg_info array to define properties of internal functions.
 * It's also used for the return type.
 */
typedefstruct_zend_internal_function_info {
uintptr_trequired_num_args;
zend_typetype;
constchar*default_value;
} zend_internal_function_info;

struct_zend_op_array {
/* Common elements */
uint8_ttype;
uint8_targ_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_tfn_flags;
zend_string*function_name;
zend_class_entry*scope;
zend_function*prototype;
uint32_tnum_args;
uint32_trequired_num_args;
zend_arg_info*arg_info;
HashTable*attributes;
ZEND_MAP_PTR_DEF(void**, run_time_cache);
zend_string*doc_comment;
uint32_tT; /* number of temporary variables */
constzend_property_info*prop_info; /* The corresponding prop_info if this is a hook. */
/* END of common elements */

intcache_size; /* number of run_time_cache_slots * sizeof(void*) */
intlast_var; /* number of CV variables */
uint32_tlast; /* number of opcodes */

zend_op*opcodes;
ZEND_MAP_PTR_DEF(HashTable*, static_variables_ptr);
HashTable*static_variables;
zend_string**vars; /* names of CV variables */

uint32_t*refcount;

intlast_live_range;
intlast_try_catch;
zend_live_range*live_range;
zend_try_catch_element*try_catch_array;

zend_string*filename;
uint32_tline_start;
uint32_tline_end;

intlast_literal;
uint32_tnum_dynamic_func_defs;
zval*literals;

/* Functions that are declared dynamically are stored here and
 * referenced by index from opcodes. */
zend_op_array**dynamic_func_defs;

void*reserved[ZEND_MAX_RESERVED_RESOURCES];
};


#defineZEND_RETURN_VALUE 0
#defineZEND_RETURN_REFERENCE 1

#defineINTERNAL_FUNCTION_PARAMETERS zend_execute_data *execute_data, zval *return_value
#defineINTERNAL_FUNCTION_PARAM_PASSTHRU execute_data, return_value

/* zend_internal_function_handler */
typedefvoid (ZEND_FASTCALL*zif_handler)(INTERNAL_FUNCTION_PARAMETERS);

typedefstruct_zend_internal_function {
/* Common elements */
uint8_ttype;
uint8_targ_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_tfn_flags;
zend_string*function_name;
zend_class_entry*scope;
zend_function*prototype;
uint32_tnum_args;
uint32_trequired_num_args;
zend_internal_arg_info*arg_info;
HashTable*attributes;
ZEND_MAP_PTR_DEF(void**, run_time_cache);
zend_string*doc_comment;
uint32_tT; /* number of temporary variables */
constzend_property_info*prop_info; /* The corresponding prop_info if this is a hook. */
/* END of common elements */

zif_handlerhandler;
struct_zend_module_entry*module;
constzend_frameless_function_info*frameless_function_infos;
void*reserved[ZEND_MAX_RESERVED_RESOURCES];
} zend_internal_function;

#defineZEND_FN_SCOPE_NAME(function) ((function) && (function)->common.scope ? ZSTR_VAL((function)->common.scope->name) : "")

union_zend_function {
uint8_ttype; /* MUST be the first element of this struct! */
uint32_tquick_arg_flags;

struct {
uint8_ttype; /* never used */
uint8_targ_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_tfn_flags;
zend_string*function_name;
zend_class_entry*scope;
zend_function*prototype;
uint32_tnum_args;
uint32_trequired_num_args;
zend_arg_info*arg_info; /* index -1 represents the return value info, if any */
HashTable*attributes;
ZEND_MAP_PTR_DEF(void**, run_time_cache);
zend_string*doc_comment;
uint32_tT; /* number of temporary variables */
constzend_property_info*prop_info; /* The corresponding prop_info if this is a hook. */
 } common;

zend_op_arrayop_array;
zend_internal_functioninternal_function;
};

struct_zend_execute_data {
constzend_op*opline; /* executed opline */
zend_execute_data*call; /* current call */
zval*return_value;
zend_function*func; /* executed function */
zvalThis; /* this + call_info + num_args */
zend_execute_data*prev_execute_data;
zend_array*symbol_table;
void**run_time_cache; /* cache op_array->run_time_cache */
zend_array*extra_named_params;
};

#defineZEND_CALL_HAS_THIS IS_OBJECT_EX

/* Top 16 bits of Z_TYPE_INFO(EX(This)) are used as call_info flags */
#defineZEND_CALL_FUNCTION (0 << 16)
#defineZEND_CALL_CODE (1 << 16)
#defineZEND_CALL_NESTED (0 << 17)
#defineZEND_CALL_TOP (1 << 17)
#defineZEND_CALL_ALLOCATED (1 << 18)
#defineZEND_CALL_FREE_EXTRA_ARGS (1 << 19)
#defineZEND_CALL_HAS_SYMBOL_TABLE (1 << 20)
#defineZEND_CALL_RELEASE_THIS (1 << 21)
#defineZEND_CALL_CLOSURE (1 << 22)
#defineZEND_CALL_FAKE_CLOSURE (1 << 23) /* Same as ZEND_ACC_FAKE_CLOSURE */
#defineZEND_CALL_GENERATOR (1 << 24)
#defineZEND_CALL_DYNAMIC (1 << 25)
#defineZEND_CALL_MAY_HAVE_UNDEF (1 << 26)
#defineZEND_CALL_HAS_EXTRA_NAMED_PARAMS (1 << 27)
#defineZEND_CALL_OBSERVED (1 << 28) /* "fcall_begin" observer handler may set this flag */
/* to prevent optimization in RETURN handler and */
/* keep all local variables for "fcall_end" handler */
#defineZEND_CALL_JIT_RESERVED (1 << 29) /* reserved for tracing JIT */
#defineZEND_CALL_NEEDS_REATTACH (1 << 30)
#defineZEND_CALL_SEND_ARG_BY_REF (1u << 31)

#defineZEND_CALL_NESTED_FUNCTION (ZEND_CALL_FUNCTION | ZEND_CALL_NESTED)
#defineZEND_CALL_NESTED_CODE (ZEND_CALL_CODE | ZEND_CALL_NESTED)
#defineZEND_CALL_TOP_FUNCTION (ZEND_CALL_TOP | ZEND_CALL_FUNCTION)
#defineZEND_CALL_TOP_CODE (ZEND_CALL_CODE | ZEND_CALL_TOP)

#defineZEND_CALL_INFO(call) \
 Z_TYPE_INFO((call)->This)

#defineZEND_CALL_KIND_EX(call_info) \
 (call_info & (ZEND_CALL_CODE | ZEND_CALL_TOP))

#defineZEND_CALL_KIND(call) \
 ZEND_CALL_KIND_EX(ZEND_CALL_INFO(call))

#defineZEND_ADD_CALL_FLAG_EX(call_info, flag) do { \
 call_info |= (flag); \
 } while (0)

#defineZEND_DEL_CALL_FLAG_EX(call_info, flag) do { \
 call_info &= ~(flag); \
 } while (0)

#defineZEND_ADD_CALL_FLAG(call, flag) do { \
 ZEND_ADD_CALL_FLAG_EX(Z_TYPE_INFO((call)->This), flag); \
 } while (0)

#defineZEND_DEL_CALL_FLAG(call, flag) do { \
 ZEND_DEL_CALL_FLAG_EX(Z_TYPE_INFO((call)->This), flag); \
 } while (0)

#defineZEND_CALL_NUM_ARGS(call) \
 (call)->This.u2.num_args

/* Ensure the correct alignment before slots calculation */
ZEND_STATIC_ASSERT(ZEND_MM_ALIGNED_SIZE(sizeof(zval)) ==sizeof(zval),
"zval must be aligned by ZEND_MM_ALIGNMENT");
/* A number of call frame slots (zvals) reserved for zend_execute_data. */
#defineZEND_CALL_FRAME_SLOT \
 ((int)((sizeof(zend_execute_data) + sizeof(zval) - 1) / sizeof(zval)))

#defineZEND_CALL_VAR(call, n) \
 ((zval*)(((char*)(call)) + ((int)(n))))

#defineZEND_CALL_VAR_NUM(call, n) \
 (((zval*)(call)) + (ZEND_CALL_FRAME_SLOT + ((int)(n))))

#defineZEND_CALL_ARG(call, n) \
 ZEND_CALL_VAR_NUM(call, ((int)(n)) - 1)

#defineEX(element) ((execute_data)->element)

#defineEX_CALL_INFO() ZEND_CALL_INFO(execute_data)
#defineEX_CALL_KIND() ZEND_CALL_KIND(execute_data)
#defineEX_NUM_ARGS() ZEND_CALL_NUM_ARGS(execute_data)

#defineZEND_CALL_USES_STRICT_TYPES(call) \
 (((call)->func->common.fn_flags & ZEND_ACC_STRICT_TYPES) != 0)

#defineEX_USES_STRICT_TYPES() \
 ZEND_CALL_USES_STRICT_TYPES(execute_data)

#defineZEND_ARG_USES_STRICT_TYPES() \
 (EG(current_execute_data)->prev_execute_data && \
 EG(current_execute_data)->prev_execute_data->func && \
 ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data)->prev_execute_data))

#defineZEND_FLF_ARG_USES_STRICT_TYPES() \
 (EG(current_execute_data) && \
 EG(current_execute_data)->func && \
 ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data)))

#defineZEND_RET_USES_STRICT_TYPES() \
 ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data))

#defineEX_VAR(n) ZEND_CALL_VAR(execute_data, n)
#defineEX_VAR_NUM(n) ZEND_CALL_VAR_NUM(execute_data, n)

#defineEX_VAR_TO_NUM(n) ((uint32_t)((n) / sizeof(zval) - ZEND_CALL_FRAME_SLOT))
#defineEX_NUM_TO_VAR(n) ((uint32_t)(((n) + ZEND_CALL_FRAME_SLOT) * sizeof(zval)))

#defineZEND_OPLINE_TO_OFFSET(opline, target) \
 ((char*)(target) - (char*)(opline))

#defineZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline_num) \
 ((char*)&(op_array)->opcodes[opline_num] - (char*)(opline))

#defineZEND_OFFSET_TO_OPLINE(base, offset) \
 ((zend_op*)(((char*)(base)) + (int)offset))

#defineZEND_OFFSET_TO_OPLINE_NUM(op_array, base, offset) \
 (ZEND_OFFSET_TO_OPLINE(base, offset) - op_array->opcodes)

#ifZEND_USE_ABS_JMP_ADDR

/* run-time jump target */
# defineOP_JMP_ADDR(opline, node) \
 (node).jmp_addr

# defineZEND_SET_OP_JMP_ADDR(opline, node, val) do { \
 (node).jmp_addr = (val); \
 } while (0)

/* convert jump target from compile-time to run-time */
# defineZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, node) do { \
 (node).jmp_addr = (op_array)->opcodes + (node).opline_num; \
 } while (0)

/* convert jump target back from run-time to compile-time */
# defineZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, node) do { \
 (node).opline_num = (node).jmp_addr - (op_array)->opcodes; \
 } while (0)

#else

/* run-time jump target */
# defineOP_JMP_ADDR(opline, node) \
 ZEND_OFFSET_TO_OPLINE(opline, (node).jmp_offset)

# defineZEND_SET_OP_JMP_ADDR(opline, node, val) do { \
 (node).jmp_offset = ZEND_OPLINE_TO_OFFSET(opline, val); \
 } while (0)

/* convert jump target from compile-time to run-time */
# defineZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, node) do { \
 (node).jmp_offset = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, (node).opline_num); \
 } while (0)

/* convert jump target back from run-time to compile-time */
# defineZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, node) do { \
 (node).opline_num = ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, (node).jmp_offset); \
 } while (0)

#endif

/* constant-time constant */
# defineCT_CONSTANT_EX(op_array, num) \
 ((op_array)->literals + (num))

# defineCT_CONSTANT(node) \
 CT_CONSTANT_EX(CG(active_op_array), (node).constant)

#ifZEND_USE_ABS_CONST_ADDR

/* run-time constant */
# defineRT_CONSTANT(opline, node) \
 (node).zv

/* convert constant from compile-time to run-time */
# defineZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, node) do { \
 (node).zv = CT_CONSTANT_EX(op_array, (node).constant); \
 } while (0)

#else

/* At run-time, constants are allocated together with op_array->opcodes
 * and addressed relatively to current opline.
 */

/* run-time constant */
# defineRT_CONSTANT(opline, node) \
 ((zval*)(((char*)(opline)) + (int32_t)(node).constant))

/* convert constant from compile-time to run-time */
# defineZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, node) do { \
 (node).constant = \
 (((char*)CT_CONSTANT_EX(op_array, (node).constant)) - \
 ((char*)opline)); \
 } while (0)

#endif

/* convert constant back from run-time to compile-time */
#defineZEND_PASS_TWO_UNDO_CONSTANT(op_array, opline, node) do { \
 (node).constant = RT_CONSTANT(opline, node) - (op_array)->literals; \
 } while (0)

#defineRUN_TIME_CACHE(op_array) \
 ZEND_MAP_PTR_GET((op_array)->run_time_cache)

#defineZEND_OP_ARRAY_EXTENSION(op_array, handle) \
 ((void**)RUN_TIME_CACHE(op_array))[handle]

#defineIS_UNUSED 0 /* Unused operand */
#defineIS_CONST (1<<0)
#defineIS_TMP_VAR (1<<1)
#defineIS_VAR (1<<2)
#defineIS_CV (1<<3) /* Compiled variable */

/* Used for result.type of smart branch instructions */
#defineIS_SMART_BRANCH_JMPZ (1<<4)
#defineIS_SMART_BRANCH_JMPNZ (1<<5)

#defineZEND_EXTRA_VALUE 1

#include"zend_globals.h"

typedefenum_zend_compile_position {
ZEND_COMPILE_POSITION_AT_SHEBANG=0,
ZEND_COMPILE_POSITION_AT_OPEN_TAG,
ZEND_COMPILE_POSITION_AFTER_OPEN_TAG
} zend_compile_position;

BEGIN_EXTERN_C()

voidinit_compiler(void);
voidshutdown_compiler(void);
voidzend_init_compiler_data_structures(void);

voidzend_oparray_context_begin(zend_oparray_context*prev_context, zend_op_array*op_array);
voidzend_oparray_context_end(zend_oparray_context*prev_context);
voidzend_file_context_begin(zend_file_context*prev_context);
voidzend_file_context_end(zend_file_context*prev_context);

externZEND_APIzend_op_array*(*zend_compile_file)(zend_file_handle*file_handle, inttype);
externZEND_APIzend_op_array*(*zend_compile_string)(zend_string*source_string, constchar*filename, zend_compile_positionposition);

ZEND_APIintZEND_FASTCALLlex_scan(zval*zendlval, zend_parser_stack_elem*elem);
voidstartup_scanner(void);
voidshutdown_scanner(void);

ZEND_APIzend_string*zend_set_compiled_filename(zend_string*new_compiled_filename);
ZEND_APIvoidzend_restore_compiled_filename(zend_string*original_compiled_filename);
ZEND_APIzend_string*zend_get_compiled_filename(void);
ZEND_APIintzend_get_compiled_lineno(void);
ZEND_APIsize_tzend_get_scanned_file_offset(void);

ZEND_APIzend_string*zend_get_compiled_variable_name(constzend_op_array*op_array, uint32_tvar);

#ifdefZTS
constchar*zend_get_zendtext(void);
intzend_get_zendleng(void);
#endif

typedefzend_result (ZEND_FASTCALL*unary_op_type)(zval*, zval*);
typedefzend_result (ZEND_FASTCALL*binary_op_type)(zval*, zval*, zval*);

ZEND_APIunary_op_typeget_unary_op(intopcode);
ZEND_APIbinary_op_typeget_binary_op(intopcode);

voidzend_stop_lexing(void);
voidzend_emit_final_return(boolreturn_one);

typedefenum {
ZEND_MODIFIER_TARGET_PROPERTY=0,
ZEND_MODIFIER_TARGET_METHOD,
ZEND_MODIFIER_TARGET_CONSTANT,
ZEND_MODIFIER_TARGET_CPP,
ZEND_MODIFIER_TARGET_PROPERTY_HOOK,
} zend_modifier_target;

/* Used during AST construction */
zend_ast*zend_ast_append_str(zend_ast*left, zend_ast*right);
zend_ast*zend_negate_num_string(zend_ast*ast);
uint32_tzend_add_class_modifier(uint32_tflags, uint32_tnew_flag);
uint32_tzend_add_anonymous_class_modifier(uint32_tflags, uint32_tnew_flag);
uint32_tzend_add_member_modifier(uint32_tflags, uint32_tnew_flag, zend_modifier_targettarget);

uint32_tzend_modifier_token_to_flag(zend_modifier_targettarget, uint32_tflags);
uint32_tzend_modifier_list_to_flags(zend_modifier_targettarget, zend_ast*modifiers);

boolzend_handle_encoding_declaration(zend_ast*ast);

ZEND_APIzend_class_entry*zend_bind_class_in_slot(
zval*class_table_slot, zval*lcname, zend_string*lc_parent_name);
ZEND_APIzend_resultdo_bind_function(zend_function*func, zval*lcname);
ZEND_APIzend_resultdo_bind_class(zval*lcname, zend_string*lc_parent_name);

voidzend_resolve_goto_label(zend_op_array*op_array, zend_op*opline);

ZEND_APIvoidfunction_add_ref(zend_function*function);
zend_string*zval_make_interned_string(zval*zv);

#defineINITIAL_OP_ARRAY_SIZE 64


/* helper functions in zend_language_scanner.l */
struct_zend_arena;

ZEND_APIzend_op_array*compile_file(zend_file_handle*file_handle, inttype);
ZEND_APIzend_op_array*compile_string(zend_string*source_string, constchar*filename, zend_compile_positionposition);
ZEND_APIzend_op_array*compile_filename(inttype, zend_string*filename);
ZEND_APIzend_ast*zend_compile_string_to_ast(
zend_string*code, struct_zend_arena**ast_arena, zend_string*filename);
ZEND_APIzend_resultzend_execute_scripts(inttype, zval*retval, intfile_count, ...);
ZEND_APIzend_resultzend_execute_script(inttype, zval*retval, zend_file_handle*file_handle);
ZEND_APIzend_resultopen_file_for_scanning(zend_file_handle*file_handle);
ZEND_APIvoidinit_op_array(zend_op_array*op_array, uint8_ttype, intinitial_ops_size);
ZEND_APIvoiddestroy_op_array(zend_op_array*op_array);
ZEND_APIvoidzend_destroy_static_vars(zend_op_array*op_array);
ZEND_APIvoidzend_destroy_file_handle(zend_file_handle*file_handle);
ZEND_APIvoidzend_cleanup_mutable_class_data(zend_class_entry*ce);
ZEND_APIvoidzend_cleanup_internal_class_data(zend_class_entry*ce);
ZEND_APIvoidzend_type_release(zend_typetype, boolpersistent);
ZEND_APIzend_string*zend_create_member_string(zend_string*class_name, zend_string*member_name);


ZEND_APIZEND_COLDvoidzend_user_exception_handler(void);

#definezend_try_exception_handler() do { \
 if (UNEXPECTED(EG(exception))) { \
 if (Z_TYPE(EG(user_exception_handler)) != IS_UNDEF) { \
 zend_user_exception_handler(); \
 } \
 } \
 } while (0)

voidzend_free_internal_arg_info(zend_internal_function*function);
ZEND_APIvoiddestroy_zend_function(zend_function*function);
ZEND_APIvoidzend_function_dtor(zval*zv);
ZEND_APIvoiddestroy_zend_class(zval*zv);
voidzend_class_add_ref(zval*zv);

ZEND_APIzend_string*zend_mangle_property_name(constchar*src1, size_tsrc1_length, constchar*src2, size_tsrc2_length, boolinternal);
#definezend_unmangle_property_name(mangled_property, class_name, prop_name) \
 zend_unmangle_property_name_ex(mangled_property, class_name, prop_name, NULL)
ZEND_APIzend_resultzend_unmangle_property_name_ex(constzend_string*name, constchar**class_name, constchar**prop_name, size_t*prop_len);

staticzend_always_inlineconstchar*zend_get_unmangled_property_name(constzend_string*mangled_prop) {
constchar*class_name, *prop_name;
zend_unmangle_property_name(mangled_prop, &class_name, &prop_name);
returnprop_name;
}

#defineZEND_FUNCTION_DTOR zend_function_dtor
#defineZEND_CLASS_DTOR destroy_zend_class

typedefbool (*zend_needs_live_range_cb)(zend_op_array*op_array, zend_op*opline);
ZEND_APIvoidzend_recalc_live_ranges(
zend_op_array*op_array, zend_needs_live_range_cbneeds_live_range);

ZEND_APIvoidpass_two(zend_op_array*op_array);
ZEND_APIboolzend_is_compiling(void);
ZEND_APIchar*zend_make_compiled_string_description(constchar*name);
ZEND_APIvoidzend_initialize_class_data(zend_class_entry*ce, boolnullify_handlers);
uint32_tzend_get_class_fetch_type(constzend_string*name);
ZEND_APIuint8_tzend_get_call_op(constzend_op*init_op, zend_function*fbc, boolresult_used);
ZEND_APIboolzend_is_smart_branch(constzend_op*opline);

typedefbool (*zend_auto_global_callback)(zend_string*name);
typedefstruct_zend_auto_global {
zend_string*name;
zend_auto_global_callbackauto_global_callback;