Optimization Proposal: Compile-time Resolution of Default Arguments

[tahaghafuri]

Description

Description

Currently, when PHP functions have default arguments containing PHP code expressions (like __FILE__.$a), these expressions are stored as AST nodes and evaluated at runtime via the ZEND_RECV_INIT opcode. This approach has performance implications since it requires runtime evaluation of the AST for each function call where the default argument is used.

Current Behavior

function example($param = __FILE__ . '/suffix') {
// Function body
}

This currently generates a ZEND_RECV_INIT opcode that stores the expression __FILE__ . '/suffix' as an AST node for runtime evaluation.

Proposed Behavior

The same code would be compiled into bytecode operations, potentially like:

1. Check if argument was provided
2. If not, execute the compiled bytecode for the default value computation
3. Jump to function body

Benefits

1. Performance Improvement: Eliminates the overhead of storing and evaluating AST nodes at runtime
2. Memory Optimization: Reduces memory usage by storing compiled bytecode instead of AST structures
3. Execution Efficiency: Allows for potential compile-time optimizations of default value expressions

Technical Considerations

• The new opcode would need to handle both simple and complex expressions appropriately
• Special handling may be required for dynamic values like __FILE__
• Backward compatibility should be maintained for edge cases

Similar Precedents

This optimization approach is similar to how PHP already handles static variable initialization through:

• ZEND_BIND_STATIC
• ZEND_BIND_INIT_STATIC_OR_JMP

[tahaghafuri]

@dstogov @zsuraski

[iluuu1994]

This is not true.

function example($param = __FILE__ . '/suffix') {
    echo $param;
}

$ php -d opcache.enable_cli=1 -d opcache.opt_debug_level=0x20000 test.php

example:
     ; (lines=3, args=1, vars=1, tmps=0)
     ; (after optimizer)
     ; /home/ilutov/Developer/php-src/test.php:3-5
0000 CV0($param) = RECV_INIT 1 string("/home/ilutov/Developer/php-src/test.php/suffix")
0001 ECHO CV0($param)
0002 RETURN null

Constant ASTs are only stored when they cannot be resolved at compile time.

function example($param = UNKNOWN . '/suffix') {
    echo $param;
}

$ php -d opcache.enable_cli=1 -d opcache.opt_debug_level=0x20000 test.php

example:
     ; (lines=3, args=1, vars=1, tmps=0)
     ; (after optimizer)
     ; /home/ilutov/Developer/php-src/test.php:3-5
0000 CV0($param) = RECV_INIT 1 zval(type=11)
0001 ECHO CV0($param)
0002 RETURN null

Also, please don't ping people unless they have asked for it.

[tahaghafuri]

For Example:

<?php
function test($arg = new TestClass()){}

new TestClass() stored as AST

[iluuu1994]

@tahaghafuri Right, new will use a constant AST, but since there is some overhead to new anyway (allocation, property initialization, etc.) this is not particularly important to optimize. It's also not immediately clear whether 2 additional opcodes (ZEND_NEW, ZEND_DO_FCALL) would necessarily be faster. ZEND_RECV_INIT is required anyway, and would need to jump over the default initializer. This would also break some engine assuptions, because all RECV/RECV_INIT opcodes are currently placed at the very start of the function.