feat(regalloc): support pseudo instructions and accurate spills

benchmarks/regalloc_spill_cases/00_low_pressure_chain.dsl

@@ -0,0 +1,12 @@
+# Low-pressure dependency chain: values die quickly and should not spill.
+t00 = add(a, b)
+t01 = mul(t00, c)
+t02 = sub(t01, d)
+t03 = add(t02, a)
+t04 = mul(t03, b)
+t05 = sub(t04, c)
+t06 = add(t05, d)
+t07 = mul(t06, a)
+t08 = sub(t07, b)
+t09 = add(t08, c)
+return t09

benchmarks/regalloc_spill_cases/01_wide_fanout_32.dsl

@@ -0,0 +1,67 @@
+# Threshold pressure: 32 long-lived values feed a balanced reduction tree.
+# Four recurrence chains keep every definition unique under LLVM O2.
+v00 = add(a, b)
+v01 = sub(c, d)
+v02 = mul(a, c)
+v03 = div(b, d)
+v04 = add(v00, c)
+v05 = sub(v01, d)
+v06 = mul(v02, a)
+v07 = div(v03, b)
+v08 = sub(v04, d)
+v09 = mul(v05, a)
+v10 = add(v06, b)
+v11 = div(v07, c)
+v12 = mul(v08, a)
+v13 = add(v09, b)
+v14 = sub(v10, c)
+v15 = div(v11, d)
+v16 = add(v12, b)
+v17 = sub(v13, c)
+v18 = mul(v14, d)
+v19 = div(v15, a)
+v20 = sub(v16, c)
+v21 = mul(v17, d)
+v22 = add(v18, a)
+v23 = div(v19, b)
+v24 = mul(v20, d)
+v25 = add(v21, a)
+v26 = sub(v22, b)
+v27 = div(v23, c)
+v28 = add(v24, a)
+v29 = sub(v25, b)
+v30 = mul(v26, c)
+v31 = div(v27, d)
+
+p00 = add(v00, v01)
+p01 = add(v02, v03)
+p02 = add(v04, v05)
+p03 = add(v06, v07)
+p04 = add(v08, v09)
+p05 = add(v10, v11)
+p06 = add(v12, v13)
+p07 = add(v14, v15)
+p08 = add(v16, v17)
+p09 = add(v18, v19)
+p10 = add(v20, v21)
+p11 = add(v22, v23)
+p12 = add(v24, v25)
+p13 = add(v26, v27)
+p14 = add(v28, v29)
+p15 = add(v30, v31)
+q00 = add(p00, p01)
+q01 = add(p02, p03)
+q02 = add(p04, p05)
+q03 = add(p06, p07)
+q04 = add(p08, p09)
+q05 = add(p10, p11)
+q06 = add(p12, p13)
+q07 = add(p14, p15)
+r00 = add(q00, q01)
+r01 = add(q02, q03)
+r02 = add(q04, q05)
+r03 = add(q06, q07)
+s00 = add(r00, r01)
+s01 = add(r02, r03)
+out = add(s00, s01)
+return out

benchmarks/regalloc_spill_cases/02_double_use_40.dsl

@@ -0,0 +1,124 @@
+# Sustained pressure: 40 values are consumed once forward and once in reverse.
+# The second use prevents the first reduction from ending their live ranges.
+v00 = add(a, b)
+v01 = sub(c, d)
+v02 = mul(a, c)
+v03 = div(b, d)
+v04 = add(v00, c)
+v05 = sub(v01, d)
+v06 = mul(v02, a)
+v07 = div(v03, b)
+v08 = sub(v04, d)
+v09 = mul(v05, a)
+v10 = add(v06, b)
+v11 = div(v07, c)
+v12 = mul(v08, a)
+v13 = add(v09, b)
+v14 = sub(v10, c)
+v15 = div(v11, d)
+v16 = add(v12, b)
+v17 = sub(v13, c)
+v18 = mul(v14, d)
+v19 = div(v15, a)
+v20 = sub(v16, c)
+v21 = mul(v17, d)
+v22 = add(v18, a)
+v23 = div(v19, b)
+v24 = mul(v20, d)
+v25 = add(v21, a)
+v26 = sub(v22, b)
+v27 = div(v23, c)
+v28 = add(v24, a)
+v29 = sub(v25, b)
+v30 = mul(v26, c)
+v31 = div(v27, d)
+v32 = sub(v28, b)
+v33 = mul(v29, c)
+v34 = add(v30, d)
+v35 = div(v31, a)
+v36 = mul(v32, c)
+v37 = add(v33, d)
+v38 = sub(v34, a)
+v39 = div(v35, b)
+
+f00 = add(v00, v01)
+f01 = add(f00, v02)
+f02 = add(f01, v03)
+f03 = add(f02, v04)
+f04 = add(f03, v05)
+f05 = add(f04, v06)
+f06 = add(f05, v07)
+f07 = add(f06, v08)
+f08 = add(f07, v09)
+f09 = add(f08, v10)
+f10 = add(f09, v11)
+f11 = add(f10, v12)
+f12 = add(f11, v13)
+f13 = add(f12, v14)
+f14 = add(f13, v15)
+f15 = add(f14, v16)
+f16 = add(f15, v17)
+f17 = add(f16, v18)
+f18 = add(f17, v19)
+f19 = add(f18, v20)
+f20 = add(f19, v21)
+f21 = add(f20, v22)
+f22 = add(f21, v23)
+f23 = add(f22, v24)
+f24 = add(f23, v25)
+f25 = add(f24, v26)
+f26 = add(f25, v27)
+f27 = add(f26, v28)
+f28 = add(f27, v29)
+f29 = add(f28, v30)
+f30 = add(f29, v31)
+f31 = add(f30, v32)
+f32 = add(f31, v33)
+f33 = add(f32, v34)
+f34 = add(f33, v35)
+f35 = add(f34, v36)
+f36 = add(f35, v37)
+f37 = add(f36, v38)
+f38 = add(f37, v39)
+
+r00 = mul(v39, v38)
+r01 = add(r00, v37)
+r02 = add(r01, v36)
+r03 = add(r02, v35)
+r04 = add(r03, v34)
+r05 = add(r04, v33)
+r06 = add(r05, v32)
+r07 = add(r06, v31)
+r08 = add(r07, v30)
+r09 = add(r08, v29)
+r10 = add(r09, v28)
+r11 = add(r10, v27)
+r12 = add(r11, v26)
+r13 = add(r12, v25)
+r14 = add(r13, v24)
+r15 = add(r14, v23)
+r16 = add(r15, v22)
+r17 = add(r16, v21)
+r18 = add(r17, v20)
+r19 = add(r18, v19)
+r20 = add(r19, v18)
+r21 = add(r20, v17)
+r22 = add(r21, v16)
+r23 = add(r22, v15)
+r24 = add(r23, v14)
+r25 = add(r24, v13)
+r26 = add(r25, v12)
+r27 = add(r26, v11)
+r28 = add(r27, v10)
+r29 = add(r28, v09)
+r30 = add(r29, v08)
+r31 = add(r30, v07)
+r32 = add(r31, v06)
+r33 = add(r32, v05)
+r34 = add(r33, v04)
+r35 = add(r34, v03)
+r36 = add(r35, v02)
+r37 = add(r36, v01)
+r38 = add(r37, v00)
+out = add(f38, r38)
+return out

benchmarks/regalloc_spill_cases/03_lifetime_holes_36.dsl

@@ -0,0 +1,137 @@
+# Lifetime-hole pressure: 36 anchors are touched, ignored, then reused later.
+# Linear intervals span the quiet middle region; LLVM may split live ranges.
+v00 = add(a, b)
+v01 = sub(c, d)
+v02 = mul(a, c)
+v03 = div(b, d)
+v04 = add(v00, c)
+v05 = sub(v01, d)
+v06 = mul(v02, a)
+v07 = div(v03, b)
+v08 = sub(v04, d)
+v09 = mul(v05, a)
+v10 = add(v06, b)
+v11 = div(v07, c)
+v12 = mul(v08, a)
+v13 = add(v09, b)
+v14 = sub(v10, c)
+v15 = div(v11, d)
+v16 = add(v12, b)
+v17 = sub(v13, c)
+v18 = mul(v14, d)
+v19 = div(v15, a)
+v20 = sub(v16, c)
+v21 = mul(v17, d)
+v22 = add(v18, a)
+v23 = div(v19, b)
+v24 = mul(v20, d)
+v25 = add(v21, a)
+v26 = sub(v22, b)
+v27 = div(v23, c)
+v28 = add(v24, a)
+v29 = sub(v25, b)
+v30 = mul(v26, c)
+v31 = div(v27, d)
+v32 = sub(v28, b)
+v33 = mul(v29, c)
+v34 = add(v30, d)
+v35 = div(v31, a)
+
+e00 = add(v00, v01)
+e01 = add(v02, v03)
+e02 = add(v04, v05)
+e03 = add(v06, v07)
+e04 = add(v08, v09)
+e05 = add(v10, v11)
+e06 = add(v12, v13)
+e07 = add(v14, v15)
+e08 = add(v16, v17)
+e09 = add(v18, v19)
+e10 = add(v20, v21)
+e11 = add(v22, v23)
+e12 = add(v24, v25)
+e13 = add(v26, v27)
+e14 = add(v28, v29)
+e15 = add(v30, v31)
+e16 = add(v32, v33)
+e17 = add(v34, v35)
+
+# Independent middle chain creates a region where the anchors are inactive.
+g00 = add(a, d)
+g01 = mul(g00, b)
+g02 = sub(g01, c)
+g03 = add(g02, a)
+g04 = mul(g03, d)
+g05 = sub(g04, b)
+g06 = add(g05, c)
+g07 = mul(g06, a)
+g08 = sub(g07, d)
+g09 = add(g08, b)
+g10 = mul(g09, c)
+g11 = sub(g10, a)
+g12 = add(g11, d)
+g13 = mul(g12, b)
+g14 = sub(g13, c)
+g15 = add(g14, a)
+g16 = mul(g15, d)
+g17 = sub(g16, b)
+g18 = add(g17, c)
+g19 = mul(g18, a)
+
+# Reuse anchors in reverse order after the lifetime hole.
+q00 = add(v35, v34)
+q01 = add(q00, v33)
+q02 = add(q01, v32)
+q03 = add(q02, v31)
+q04 = add(q03, v30)
+q05 = add(q04, v29)
+q06 = add(q05, v28)
+q07 = add(q06, v27)
+q08 = add(q07, v26)
+q09 = add(q08, v25)
+q10 = add(q09, v24)
+q11 = add(q10, v23)
+q12 = add(q11, v22)
+q13 = add(q12, v21)
+q14 = add(q13, v20)
+q15 = add(q14, v19)
+q16 = add(q15, v18)
+q17 = add(q16, v17)
+q18 = add(q17, v16)
+q19 = add(q18, v15)
+q20 = add(q19, v14)
+q21 = add(q20, v13)
+q22 = add(q21, v12)
+q23 = add(q22, v11)
+q24 = add(q23, v10)
+q25 = add(q24, v09)
+q26 = add(q25, v08)
+q27 = add(q26, v07)
+q28 = add(q27, v06)
+q29 = add(q28, v05)
+q30 = add(q29, v04)
+q31 = add(q30, v03)
+q32 = add(q31, v02)
+q33 = add(q32, v01)
+q34 = add(q33, v00)
+
+er00 = add(e00, e01)
+er01 = add(er00, e02)
+er02 = add(er01, e03)
+er03 = add(er02, e04)
+er04 = add(er03, e05)
+er05 = add(er04, e06)
+er06 = add(er05, e07)
+er07 = add(er06, e08)
+er08 = add(er07, e09)
+er09 = add(er08, e10)
+er10 = add(er09, e11)
+er11 = add(er10, e12)
+er12 = add(er11, e13)
+er13 = add(er12, e14)
+er14 = add(er13, e15)
+er15 = add(er14, e16)
+er16 = add(er15, e17)
+out0 = add(q34, er16)
+out1 = add(out0, g19)
+return out1