A bitmask integer that controls which optimisation passes the OPcache optimizer executes when compiling PHP scripts. The default value 0x7FFEBFFF enables all safe passes. Each bit enables one pass:
'
. ''
. '| Bit | Pass | Description |
|---|
'
. '0x0001 | Pre-evaluate constant operations | Evaluates constant expressions at compile time (e.g. 1+2 becomes 3, string concatenations of literals are merged). |
'
. '0x0004 | Jump optimization | Converts sequences of jumps into direct jumps to the final target, eliminating unnecessary branches and unreachable code after unconditional jumps. |
'
. '0x0008 | Optimize function calls | Replaces calls to certain internal functions with faster opcode equivalents (e.g. strlen(), defined(), call_user_func()). |
'
. '0x0010 | CFG-based optimization | Builds a control flow graph and performs block-level optimisations: merging adjacent blocks, removing empty blocks, and simplifying conditional branches. |
'
. '0x0020 | Data flow analysis | SSA-based optimisations using Static Single Assignment form: type inference, range propagation, and value numbering to eliminate redundant computations. |
'
. '0x0040 | Call graph analysis | Analyses call relationships between functions to enable inter-procedural optimisations such as determining which functions can be inlined. |
'
. '0x0080 | SCCP (constant propagation) | Sparse Conditional Constant Propagation — propagates known constant values through the program and eliminates branches that can never be taken. |
'
. '0x0100 | Optimize temp variables | Reduces the number of temporary variables used by reusing slots, decreasing the memory footprint of each compiled function. |
'
. '0x0200 | NOP removal | Removes NOP (no-operation) instructions left behind by earlier optimisation passes, compacting the opcode array. |
'
. '0x0400 | Compact literals | De-duplicates identical literal values (strings, integers, floats) within a function, reducing memory usage in the literal table. |
'
. '0x0800 | Adjust used stack | Recalculates the actual stack size needed by each function after optimisation, freeing over-allocated stack slots. |
'
. '0x1000 | Compact unused variables | Removes variables that are assigned but never read, and compacts the remaining variable table to close gaps. |
'
. '0x2000 | Dead code elimination | Removes instructions whose results are never used, including assignments to variables that are overwritten before being read. |
'
. '0x4000 | Constant substitution ⚠ | Replaces references to constants defined via define() with their values. Marked unsafe because it assumes constants are never redefined; can break code using conditionally defined constants. |
'
. '0x8000 | Trivial function inlining | Inlines very simple functions that just return a constant or a parameter, eliminating function call overhead entirely. |
'
. '0x10000 | Ignore operator overloading ⚠ | Allows the optimizer to treat arithmetic operators as pure operations. Marked unsafe because classes like GMP and BCMath overload operators, and this pass may incorrectly optimize those expressions. |
'
. '
'
. '⚠ = disabled by default because it may change runtime behaviour in edge cases.
',
'opcache.inherited_hack' => 'This configuration directive is ignored.',
'opcache.dups_fix' => 'This hack should only be enabled to work around "Cannot redeclare class" errors.',
'opcache.blacklist_filename' => 'The location of the OPcache blacklist file. A blacklist file is a text file that contains the names of files that should not be accelerated, one per line. Wildcards are allowed, and prefixes can also be provided. Lines starting with a semicolon are ignored as comments.',
'opcache.max_file_size' => 'The maximum file size that OPcache will cache, in bytes. If this is 0, all files will be cached.',
'opcache.consistency_checks' => 'If non-zero, OPcache will verify the cache checksum every N requests. This should only be enabled when debugging, since it impacts performance. Removed in PHP 8.3.0.',
'opcache.force_restart_timeout' => 'The length of time to wait for a scheduled restart to begin if the cache is not being accessed, in seconds. If the timeout is hit, OPcache assumes that something has gone wrong and will kill the process holding the cache lock to permit a restart.',
'opcache.error_log' => 'OPcache error log. An empty string is treated the same as stderr, and will result in logs being sent to the standard error output (which will be the web server error log in most cases).',
'opcache.log_verbosity_level' => 'Log verbosity level. By default, only fatal errors (level 0) and errors (level 1) are logged. Other levels available are warnings (level 2), info messages (level 3), and debug messages (level 4).',
'opcache.preferred_memory_model' => 'The preferred memory model for OPcache to use. If left empty, OPcache will choose the most appropriate model, which is the correct behaviour in virtually all cases. Possible values include mmap, shm, posix, and win32.',
'opcache.protect_memory' => 'Protects shared memory from unexpected writes while executing scripts. Useful for internal debugging only.',
'opcache.restrict_api' => 'Allows calling OPcache API functions only from PHP scripts whose path starts with the specified string. An empty string means no restriction.',
'opcache.mmap_base' => 'The base address to be used for the shared memory mapping on Windows only. All PHP processes have to map the shared memory into the same address space. Use this setting to fix "Unable to reattach to base address" errors.',
'opcache.file_cache' => 'Enables and sets the second level cache directory. It should improve performance when SHM memory is full, at server restart, or SHM reset. The default empty string disables file-based caching.',
'opcache.file_cache_only' => 'Enables or disables opcode caching in shared memory.',
'opcache.file_cache_consistency_checks' => 'Enables or disables checksum validation when a script is loaded from the file cache.',
'opcache.file_cache_fallback' => 'Implies opcache.file_cache_only=1 for a certain process that failed to reattach to the shared memory. Windows only.',
'opcache.file_update_protection' => 'Prevents caching of files that are less than this number of seconds old. It protects from caching of incompletely updated files. If all file updates on your site are atomic, you may increase performance by setting this to 0.',
'opcache.huge_code_pages' => 'Enables or disables copying of PHP code (text segment) into HUGE PAGES. This should improve performance, but requires appropriate OS configuration.',
'opcache.lockfile_path' => 'Absolute path used to store shared lockfiles (for *nix only).',
'opcache.opt_debug_level' => 'Produces opcode dumps for debugging different stages of optimisations. 0x10000 will output opcodes as the compiler produced them before any optimisation occurs. 0x20000 will output opcodes after optimisation.',
'opcache.validate_permission' => 'Validates the cached file\'s permissions against the current user.',
'opcache.validate_root' => 'Prevents name collisions in chroot\'ed environments. Should be enabled in all chroot\'ed environments to prevent the access to files outside of the chroot.',
'opcache.preload' => 'Specifies a PHP script that is going to be compiled and executed at server start-up, and may preload other files by either including them or using the opcache_compile_file() function. All the entities (e.g. functions and classes) defined in these files will be available to requests out of the box, until the server is shut down.',
'opcache.preload_user' => 'Allows preloading to be run as the specified system user. This is useful for servers that start as root before switching to an unprivileged system user. Preloading as root is not allowed by default for security reasons unless this directive is explicitly set to root.',
'opcache.cache_id' => 'On Windows, all processes running the same PHP SAPI under the same user account having the same cache ID share a single OPcache instance. The value of the cache ID can be freely chosen.',
'opcache.record_warnings' => 'If enabled, OPcache will record compile-time warnings and replay them on the next include, even if it is served from cache.',
'opcache.file_cache_read_only' => 'Enables a read-only file cache. This is mainly useful in CI/Docker-style environments where a pre-warmed cache is mounted read-only.',
'opcache.jit' => 'For typical usage, this should be set to one of these string values: disable, off, tracing/on, or function. For advanced usage, a 4-digit integer CRTO is accepted where each digit controls a specific JIT optimization flag.',
'opcache.jit_buffer_size' => 'The amount of shared memory to reserve for compiled JIT code. A zero value disables the JIT.',
'opcache.jit_debug' => 'A bitmask specifying which JIT debug output to enable. Refer to zend_jit.h for possible values.',
'opcache.jit_bisect_limit' => 'Use a bisect search to debug issues with the JIT by disabling JIT compilation of functions above a specified limit. This requires compilation of a tracing function only, with trigger set to 0 or 1.',
'opcache.jit_prof_threshold' => 'When using the "profile on first request" trigger mode, this threshold determines whether a function is considered hot. The number of calls to the function divided by the number of all calls must be above this threshold.',
'opcache.jit_max_root_traces' => 'Maximum number of root traces. Setting this to 0 disables JIT trace compilation.',
'opcache.jit_max_side_traces' => 'Maximum number of side traces per root trace.',
'opcache.jit_max_exit_counters' => 'Maximum number of side trace exit counters. This limits the total number of side traces there can be (across all root traces).',
'opcache.jit_hot_loop' => 'After how many iterations a loop is considered hot.',
'opcache.jit_hot_func' => 'After how many calls a function is considered hot.',
'opcache.jit_hot_return' => 'After how many returns a return is considered hot.',
'opcache.jit_hot_side_exit' => 'After how many exits a side exit is considered hot.',
'opcache.jit_blacklist_root_trace' => 'Maximum number of attempts to compile a root trace before it is blacklisted.',
'opcache.jit_blacklist_side_trace' => 'Maximum number of attempts to compile a side trace before it is blacklisted.',
'opcache.jit_max_loop_unrolls' => 'Maximum number of attempts to unroll a loop in a side trace.',
'opcache.jit_max_recursive_calls' => 'Maximum number of unrolled recursive call loops.',
'opcache.jit_max_recursive_returns' => 'Maximum number of unrolled recursive return loops.',
'opcache.jit_max_polymorphic_calls' => 'Maximum number of attempts to inline a polymorphic (virtual or interface) call. Calls above this limit are treated as megamorphic and are not inlined.',
'opcache.jit_max_trace_length' => 'Maximum length of a single JIT trace.',
];
}
public function getConfigDataRows(): string
{
$defaults = $this->getCompiledDefaults();
$docs = self::getConfigDocs();
$iniValues = function_exists('ini_get_all') ? (ini_get_all('zend opcache', false) ?: []) : [];
$rows = [];
foreach ($this->configuration['directives'] as $key => $value) {
$changed = false;
if (array_key_exists($key, $defaults)) {
$cur = $iniValues[$key] ?? (string)$value;
$changed = (string)$defaults[$key] !== (string)$cur;
}
$class = $changed ? ' class="changed"' : '';
if ($value === false) {
$value = 'false';
} elseif ($value === true) {
$value = 'true';
}
// Format values with appropriate units
$value = match ($key) {
'opcache.memory_consumption' => $this->sizeForHumans((int)$value),
'opcache.jit_buffer_size' => $this->sizeForHumans((int)$value),
'opcache.interned_strings_buffer'=> ((int)$value) . ' MB',
'opcache.max_wasted_percentage' => number_format((float)$value * 100, 1) . '%',
'opcache.force_restart_timeout' => $value . 's',
'opcache.revalidate_freq' => $value . 's',
'opcache.file_update_protection' => $value . 's',
'opcache.optimization_level' => $this->formatOptimizationLevel((int)$value),
'opcache.jit' => $value === '' ? 'off' : $value,
default => $value,
};
$helpBtn = isset($docs[$key])
? '