Tag: Branch: Tree: e16c787f44

master

speed_build

v0.0.1

v0.0.2

v0.0.3

v0.0.4

v0.0.5

v0.0.6

v0.0.7

v0.1.0

v0.4.0

v0.4.1

v0.6.1

v0.6.2

v0.6.5

v0.6.6

v0.6.8

v0.7.0

v0.8.0

Branches Tags

${ item.name }

Create tag ${ searchTerm }

Create branch ${ searchTerm }

from 'e16c787f44'

${ noResults }

Commit Graph

1 Commits (e16c787f448ac04e5337d264f79d9302d31ba993)

Author	SHA1	Message	Date
Alessio Giacobbe	ea0ea4414a	fix(codegen): keep Zend operand read order around hoisted side effects (#52) --skip-tests ... * fix(codegen): keep Zend operand read order around hoisted side effects Lowering a later call argument or concat operand that materializes captured statements (an assignment, a call result) appended them to the enclosing statement, executing the side effect before earlier operands were read: two($j, $j = 5) with $j = 1 produced "5,5" (Zend "1,5") and $m . "," . ($m = 9) produced "9,9" (Zend "1,9"). Call arguments: Zend SENDs strictly left to right, so when a later argument hoists statements, every earlier by-value plain-variable argument is snapshotted into a temporary at its own argument position. By-reference parameters, unpacked arguments, $this and $GLOBALS are left alone. Concat chains: Zend reads a CV operand when its CONCAT opcode executes, so in the left-associated chain the first two items are read together at the first op (after both items' side effects: $s . ($s = 'b') . $s is "bbb") and each later item after the side effects of everything up to itself. The flattened braced-list lowering now snapshots a plain-variable item exactly at that read position, deferring the first item's snapshot until the second item has been lowered. Plain arithmetic is intentionally unchanged: Zend's ADD reads the CV at op time, so $k + ($k = 5) is 10 in both worlds, and the existing codegen already matches. * test(codegen): platform-neutral integer-literal suffixes in eval-order assertions * fix(codegen): detect wrapped side effects when ordering operand reads Zend sends call arguments strictly left to right and reads a concat operand's CV when its opcode executes: an assignment nested in a later argument runs after every earlier by-value argument has been sent, so pairValue($i, (int) ($i = 5)) passes the old value ("1,5"), and the same holds when the assignment is wrapped in !, unary +/-, ~, or @. shouldMaterializeOrderedOperand() only descended through BinaryOp nodes, so an assignment inside any other expression wrapper was not classified as side-effecting: no earlier operand was snapshotted and the assignment could even stay inline in the C++ argument list (php::toInt(i = 5LL)), mutating the variable at an unsequenced point. Deriving the decision from the captured statements lowering produces would miss exactly these inline cases, so the classifier now recurses structurally through every sub-expression: any wrapper of a side-effecting node is itself side-effecting. Closure and arrow function bodies do not run at creation time and stop the walk; throw, yield, yield from, and backtick expressions join the side-effecting leaves. Zend's ADD opcode still reads its CV at op time, so $k + ($k = 5) keeps its existing codegen (10 in both worlds, no snapshot). * fix(codegen): type materialized wrapper operands as dynamic temporaries A wrapper expression around a side effect (-strlen($s), a cast, error suppression) is now materialized for evaluation order, but the temp-type fallback typed it by the detected PHP type. The lowered C++ can still be dynamic — an unqualified namespaced call lowers to php::call(...), a Variant — so a php::Int temporary failed to compile in the self-build. Follow the call/binary-op policy: native scalar types only in native-types mode, otherwise a dynamic temporary.	1 month ago