Fix egraph explosion from expanding rewrite rules

Disable or reverse direction of rules that create more nodes than they
consume, causing exponential e-graph growth in matrix-heavy shaders:

- bitwise.egg: Reverse De Morgan direction to pull BitNot OUTSIDE
  (simplifying 3→1 nodes) instead of pushing INSIDE (expanding 1→3)
- rvsdg.egg: Disable Gamma distribution INTO rules (Op(Gamma,Gamma) →
  Gamma(Op,Op)) which create new inner nodes and cycle with the hoisting
  rules that pull common factors OUT
- glsl.egg: Disable Fma recognition (FAdd(FMul(a,b),c) → Fma(a,b,c))
  which fires on every float multiply-add, creating massive node counts
  in matrix-heavy code
- arithmetic.egg: Reverse Neg distribution to pull Neg OUTSIDE Add
  (factoring 2 Negs → 1) instead of pushing INSIDE (expanding 1 → 2)
- vector.egg: Disable Dot distribution over VecAdd and VecTimesScalar
  distribution over VecAdd, both of which create 2+ new nodes per firing

Author: LegNeato

rust/spirv-tools-opt/src/rules/arithmetic.egg

@@ -32,10 +32,10 @@
       ((union e (Neg x))))
 (rule ((= e (Mul (Const -1) x)))
       ((union e (Neg x))))
-; Neg distribution - ONE-DIRECTIONAL: push Neg INSIDE Add/Sub, not OUTSIDE
-; This avoids Add(Neg x, Neg y) → Neg(Add(x, y)) → Add(Neg x, Neg y) cycles
-(rule ((= e (Neg (Add x y))))
-      ((union e (Add (Neg x) (Neg y)))))
+; Neg factoring - ONE-DIRECTIONAL: pull Neg OUTSIDE Add (simplifying 2 Negs → 1)
+; The reverse (pushing Neg inside) creates 2 new Neg nodes causing explosion.
+(rule ((= e (Add (Neg x) (Neg y))))
+      ((union e (Neg (Add x y)))))
 (rule ((= e (Neg (Sub x y))))
       ((union e (Sub y x))))
 (rule ((= e (Add x (Neg x))))

rust/spirv-tools-opt/src/rules/bitwise.egg

@@ -33,11 +33,11 @@
       ((union e x)))
 
 ; De Morgan's laws - ONE-DIRECTIONAL to prevent explosion
-; We push BitNot INSIDE, not pull OUTSIDE (which would expand forever)
-(rule ((= e (BitNot (BitAnd x y))))
-      ((union e (BitOr (BitNot x) (BitNot y)))))
-(rule ((= e (BitNot (BitOr x y))))
-      ((union e (BitAnd (BitNot x) (BitNot y)))))
+; We pull BitNot OUTSIDE (simplifying 3 nodes → 1), not push INSIDE (which expands 1 → 3)
+(rule ((= e (BitOr (BitNot x) (BitNot y))))
+      ((union e (BitNot (BitAnd x y)))))
+(rule ((= e (BitAnd (BitNot x) (BitNot y))))
+      ((union e (BitNot (BitOr x y)))))
 
 ; Complement rules
 (rule ((= e (BitAnd x (BitNot x))))

rust/spirv-tools-opt/src/rules/glsl.egg

@@ -302,12 +302,13 @@
 ; Fma(a, b, c) = a*b + c (definition, for expansion if needed)
 ; But prefer Fma when available (single rounding, faster)
 
-; Recognize Fma patterns - ONE-DIRECTIONAL (prefer Fma over expanded form)
-; We don't expand Fma to FAdd(FMul...) since that's worse for performance
-(rule ((= e (FAdd (FMul a b) c)))
-      ((union e (Fma a b c))))
-(rule ((= e (FAdd c (FMul a b))))
-      ((union e (Fma a b c))))
+; DISABLED: Fma recognition — fires on every FAdd(FMul(...), ...) pattern,
+; creating new Fma nodes that cause exponential growth in matrix-heavy shaders.
+; Fma simplification rules below still work if Fma is already in the graph.
+; (rule ((= e (FAdd (FMul a b) c)))
+;       ((union e (Fma a b c))))
+; (rule ((= e (FAdd c (FMul a b))))
+;       ((union e (Fma a b c))))
 
 ; Fma with zero - ONE-DIRECTIONAL (simplify, don't expand)
 (rule ((= e (Fma a b (FConst c))) (= c 0.0))

rust/spirv-tools-opt/src/rules/rvsdg.egg

@@ -142,22 +142,21 @@
 ; select(c, true, c) = c | true = true when c is boolean
 ; But this is the same as select(c, 1, c) = c ? 1 : c which is just 1 when c is true, c when false
 
-; Gamma distributes over operations (hoisting) - ONE-DIRECTIONAL
-; Push operations INTO Gamma, not out (pulling out creates Op(Gamma, Gamma) which explodes)
-; These rules combine two Gammas with same condition into a single Gamma
-; Integer operations use GammaI
-(rule ((= e (Add (GammaI c a b) (GammaI c x y))))
-      ((union e (GammaI c (Add a x) (Add b y)))))
-(rule ((= e (Sub (GammaI c a b) (GammaI c x y))))
-      ((union e (GammaI c (Sub a x) (Sub b y)))))
-(rule ((= e (Mul (GammaI c a b) (GammaI c x y))))
-      ((union e (GammaI c (Mul a x) (Mul b y)))))
-(rule ((= e (BitAnd (GammaI c a b) (GammaI c x y))))
-      ((union e (GammaI c (BitAnd a x) (BitAnd b y)))))
-(rule ((= e (BitOr (GammaI c a b) (GammaI c x y))))
-      ((union e (GammaI c (BitOr a x) (BitOr b y)))))
-(rule ((= e (BitXor (GammaI c a b) (GammaI c x y))))
-      ((union e (GammaI c (BitXor a x) (BitXor b y)))))
+; DISABLED: Gamma distribution INTO — creates new Op nodes inside both arms,
+; forming cycles with the hoisting rules below (which pull common factors OUT).
+; The hoisting rules (lines 166+) are the simplifying direction and are kept.
+; (rule ((= e (Add (GammaI c a b) (GammaI c x y))))
+;       ((union e (GammaI c (Add a x) (Add b y)))))
+; (rule ((= e (Sub (GammaI c a b) (GammaI c x y))))
+;       ((union e (GammaI c (Sub a x) (Sub b y)))))
+; (rule ((= e (Mul (GammaI c a b) (GammaI c x y))))
+;       ((union e (GammaI c (Mul a x) (Mul b y)))))
+; (rule ((= e (BitAnd (GammaI c a b) (GammaI c x y))))
+;       ((union e (GammaI c (BitAnd a x) (BitAnd b y)))))
+; (rule ((= e (BitOr (GammaI c a b) (GammaI c x y))))
+;       ((union e (GammaI c (BitOr a x) (BitOr b y)))))
+; (rule ((= e (BitXor (GammaI c a b) (GammaI c x y))))
+;       ((union e (GammaI c (BitXor a x) (BitXor b y)))))
 
 ; Hoist common operations out of Gamma - ONE-DIRECTIONAL
 ; (c ? (x + a) : (x + b)) => x + (c ? a : b)
@@ -409,13 +408,14 @@
 ; =============================================================================
 ; Floating-Point Gamma Distribution - ONE-DIRECTIONAL
 ; =============================================================================
-; Distribution INTO GammaF (combining two conditional float values)
-(rule ((= e (FAdd (GammaF c a b) (GammaF c x y))))
-      ((union e (GammaF c (FAdd a x) (FAdd b y)))))
-(rule ((= e (FSub (GammaF c a b) (GammaF c x y))))
-      ((union e (GammaF c (FSub a x) (FSub b y)))))
-(rule ((= e (FMul (GammaF c a b) (GammaF c x y))))
-      ((union e (GammaF c (FMul a x) (FMul b y)))))
+; DISABLED: Distribution INTO GammaF — creates new FOp nodes inside both arms,
+; forming cycles with the hoisting rules below.
+; (rule ((= e (FAdd (GammaF c a b) (GammaF c x y))))
+;       ((union e (GammaF c (FAdd a x) (FAdd b y)))))
+; (rule ((= e (FSub (GammaF c a b) (GammaF c x y))))
+;       ((union e (GammaF c (FSub a x) (FSub b y)))))
+; (rule ((= e (FMul (GammaF c a b) (GammaF c x y))))
+;       ((union e (GammaF c (FMul a x) (FMul b y)))))
 
 ; Hoisting common factors OUT of GammaF - ONE-DIRECTIONAL
 (rule ((= e (GammaF c (FAdd x a) (FAdd x b))))

rust/spirv-tools-opt/src/rules/vector.egg

@@ -394,9 +394,10 @@
 ; Vector Operations Distributivity
 ; =============================================================================
 
-; VecTimesScalar distributes over VecAdd - ONE-DIRECTIONAL (distribute, don't factor)
-(rule ((= e (VecTimesScalar (VecAdd a b) s)))
-      ((union e (VecAdd (VecTimesScalar a s) (VecTimesScalar b s)))))
+; DISABLED: VecTimesScalar distribution over VecAdd — creates 2 new VecTimesScalar
+; nodes per rule firing, causing exponential growth in matrix-heavy shaders.
+; (rule ((= e (VecTimesScalar (VecAdd a b) s)))
+;       ((union e (VecAdd (VecTimesScalar a s) (VecTimesScalar b s)))))
 
 ; VecTimesScalar with scalar multiplication - ONE-DIRECTIONAL (combine scalars)
 ; Note: s1 and s2 are Expr (from VecTimesScalar args), but Mul takes IntExpr.
@@ -430,12 +431,12 @@
 ; Dot Product Additional Properties
 ; =============================================================================
 
-; Dot product distributes over VecAdd - ONE-DIRECTIONAL (expand Dot)
-; Note: Dot returns FloatExpr, so use FAdd (FloatExpr + FloatExpr -> FloatExpr)
-(rule ((= e (Dot (VecAdd a b) c)))
-      ((union e (FAdd (Dot a c) (Dot b c)))))
-(rule ((= e (Dot a (VecAdd b c))))
-      ((union e (FAdd (Dot a b) (Dot a c)))))
+; DISABLED: Dot distribution over VecAdd — creates 2 new Dot nodes per rule,
+; causing exponential growth. Matrix multiply = many Dot(VecAdd(...), ...) patterns.
+; (rule ((= e (Dot (VecAdd a b) c)))
+;       ((union e (FAdd (Dot a c) (Dot b c)))))
+; (rule ((= e (Dot a (VecAdd b c))))
+;       ((union e (FAdd (Dot a b) (Dot a c)))))
 
 ; Dot product distributes over scalar multiplication - ONE-DIRECTIONAL
 ; Note: Dot returns FloatExpr, s is Expr (from VecTimesScalar), use FMul with ExprToFloat