WIP

This reverts commit 84a1e58b97.

.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+    "editor.formatOnSave": true,
+    "[rust]": {
+        "editor.defaultFormatter": "rust-lang.rust-analyzer"
+    },
+    "rust-analyzer.cargo.features": [
+        "default"
+    ]
+}

Cargo.toml

@@ -12,7 +12,7 @@ repository = "https://github.com/bytecodealliance/regalloc2"
 
 [dependencies]
 log = { version = "0.4.8", default-features = false }
-smallvec = { version = "1.6.1", features = ["union"] }
+smallvec = { version = "1.6.1", features = ["union", "const_generics"] }
 rustc-hash = { version = "1.1.0", default-features = false }
 slice-group-by = { version = "0.3.0", default-features = false }
 hashbrown = "0.13.2"

bench_res/dcb95541a7a16564db4b15f9248ceab990a18135.txt

@@ -0,0 +1,257 @@
+compilation :: cycles :: benchmarks/shootout-keccak/benchmark.wasm
+
+  Δ = 82716376.00 ± 10452013.97 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 3.22x to 3.86x faster than tmp/wasmtime_main.so!
+
+  [109368640 115289268.00 121224220] tmp/wasmtime_main.so
+  [26120680 32572892.00 38319220] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-seqhash/benchmark.wasm
+
+  Δ = 35218172.00 ± 10139196.17 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 2.64x to 3.97x faster than tmp/wasmtime_main.so!
+
+  [45573440 50487252.00 57536460] tmp/wasmtime_main.so
+  [14076800 15269080.00 17370880] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-ed25519/benchmark.wasm
+
+  Δ = 230472644.00 ± 14955335.34 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 3.13x to 3.42x faster than tmp/wasmtime_main.so!
+
+  [324059620 331874540.00 343721760] tmp/wasmtime_main.so
+  [92807900 101401896.00 111293420] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/bz2/benchmark.wasm
+
+  Δ = 148462916.00 ± 74415954.89 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.79x to 3.37x faster than tmp/wasmtime_main.so!
+
+  [203553120 242451052.00 291165780] tmp/wasmtime_main.so
+  [87747740 93988136.00 99525600] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-ackermann/benchmark.wasm
+
+  Δ = 38242648.00 ± 16283101.77 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.63x to 2.56x faster than tmp/wasmtime_main.so!
+
+  [68094780 73289288.00 78249120] tmp/wasmtime_main.so
+  [25462000 35046640.00 47911900] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/blake3-simd/benchmark.wasm
+
+  Δ = 21865932.00 ± 4836633.92 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.76x to 2.19x faster than tmp/wasmtime_main.so!
+
+  [42437960 44226636.00 46472140] tmp/wasmtime_main.so
+  [19230460 22360704.00 25217580] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-base64/benchmark.wasm
+
+  Δ = 30766524.00 ± 8057535.50 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.71x to 2.22x faster than tmp/wasmtime_main.so!
+
+  [58863940 62678716.00 64941420] tmp/wasmtime_main.so
+  [28483860 31912192.00 39027860] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-ctype/benchmark.wasm
+
+  Δ = 26468612.00 ± 16769880.25 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.35x to 2.54x faster than tmp/wasmtime_main.so!
+
+  [44742000 54515672.00 65715120] tmp/wasmtime_main.so
+  [24041300 28047060.00 34958480] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-switch/benchmark.wasm
+
+  Δ = 44993524.00 ± 15374857.68 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.60x to 2.23x faster than tmp/wasmtime_main.so!
+
+  [87974340 93954372.00 106466280] tmp/wasmtime_main.so
+  [46232300 48960848.00 51231600] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-nestedloop/benchmark.wasm
+
+  Δ = 21867216.00 ± 5291064.57 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.62x to 2.01x faster than tmp/wasmtime_main.so!
+
+  [45180760 48782624.00 52403220] tmp/wasmtime_main.so
+  [23893540 26915408.00 29864760] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-fib2/benchmark.wasm
+
+  Δ = 21156820.00 ± 11632344.98 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.33x to 2.14x faster than tmp/wasmtime_main.so!
+
+  [47489900 49865496.00 57817820] tmp/wasmtime_main.so
+  [20262340 28708676.00 37136600] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/blind-sig/benchmark.wasm
+
+  Δ = 206300520.00 ± 49456972.18 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.53x to 1.87x faster than tmp/wasmtime_main.so!
+
+  [468801420 501884140.00 533785860] tmp/wasmtime_main.so
+  [280069560 295583620.00 313052880] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-random/benchmark.wasm
+
+  Δ = 17866328.00 ± 5058990.61 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.45x to 1.80x faster than tmp/wasmtime_main.so!
+
+  [42136400 46350848.00 49072180] tmp/wasmtime_main.so
+  [26323300 28484520.00 30908400] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/regex/benchmark.wasm
+
+  Δ = 306213000.00 ± 149004995.32 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.31x to 1.89x faster than tmp/wasmtime_main.so!
+
+  [737215040 814849904.00 927360140] tmp/wasmtime_main.so
+  [434576640 508636904.00 605740280] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-sieve/benchmark.wasm
+
+  Δ = 15761008.00 ± 9513156.34 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.23x to 1.94x faster than tmp/wasmtime_main.so!
+
+  [40248860 42579220.00 45042100] tmp/wasmtime_main.so
+  [21795160 26818212.00 34187840] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/meshoptimizer/benchmark.wasm
+
+  Δ = 25719108.00 ± 8595140.79 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.32x to 1.64x faster than tmp/wasmtime_main.so!
+
+  [75542900 79202808.00 84619440] tmp/wasmtime_main.so
+  [50271620 53483700.00 55800220] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-matrix/benchmark.wasm
+
+  Δ = 15708244.00 ± 10889969.92 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.14x to 1.78x faster than tmp/wasmtime_main.so!
+
+  [46643700 49724296.00 53101840] tmp/wasmtime_main.so
+  [26710660 34016052.00 39995200] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/spidermonkey/benchmark.wasm
+
+  Δ = 2514174744.00 ± 1857722729.16 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.11x to 1.74x faster than tmp/wasmtime_main.so!
+
+  [7653278120 8460320132.00 9199229920] tmp/wasmtime_main.so
+  [4197742280 5946145388.00 6556552620] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/pulldown-cmark/benchmark.wasm
+
+  Δ = 95998836.00 ± 94947313.64 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.00x to 1.71x faster than tmp/wasmtime_main.so!
+
+  [333846840 364658356.00 438691720] tmp/wasmtime_main.so
+  [216037300 268659520.00 322037740] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-gimli/benchmark.wasm
+
+  Δ = 1553848.00 ± 1106236.68 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.09x to 1.53x faster than tmp/wasmtime_main.so!
+
+  [5962360 6564812.00 7277160] tmp/wasmtime_main.so
+  [4538420 5010964.00 5912740] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-xblabla20/benchmark.wasm
+
+  Δ = 5108496.00 ± 3867184.58 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.07x to 1.53x faster than tmp/wasmtime_main.so!
+
+  [20042160 22127584.00 23927120] tmp/wasmtime_main.so
+  [14784460 17019088.00 19205440] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-xchacha20/benchmark.wasm
+
+  Δ = 4067360.00 ± 2084422.61 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.14x to 1.43x faster than tmp/wasmtime_main.so!
+
+  [17229340 18357984.00 19519960] tmp/wasmtime_main.so
+  [12904240 14290624.00 15326220] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/noop/benchmark.wasm
+
+  Δ = 2802768.00 ± 1567262.30 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.09x to 1.31x faster than tmp/wasmtime_main.so!
+
+  [16538500 16982392.00 18070820] tmp/wasmtime_main.so
+  [13400280 14179624.00 15124040] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/hex-simd/benchmark.wasm
+
+  Δ = 22611720.00 ± 15198082.61 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.06x to 1.31x faster than tmp/wasmtime_main.so!
+
+  [135396000 143348280.00 154255820] tmp/wasmtime_main.so
+  [112891420 120736560.00 126274080] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-ratelimit/benchmark.wasm
+
+  No difference in performance.
+
+  [49158240 61531312.00 102319960] tmp/wasmtime_main.so
+  [28723540 33731256.00 36821820] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-memmove/benchmark.wasm
+
+  No difference in performance.
+
+  [16707500 20553252.00 27217200] tmp/wasmtime_main.so
+  [13315020 16224728.00 21330760] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/intgemm-simd/benchmark.wasm
+
+  No difference in performance.
+
+  [324449640 352576952.00 413652920] tmp/wasmtime_main.so
+  [273646660 281514868.00 285492580] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-minicsv/benchmark.wasm
+
+  No difference in performance.
+
+  [8602740 9606232.00 11417000] tmp/wasmtime_main.so
+  [7234340 8023400.00 8844940] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-heapsort/benchmark.wasm
+
+  No difference in performance.
+
+  [20328440 21526748.00 22546480] tmp/wasmtime_main.so
+  [15103220 18372012.00 22779260] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/blake3-scalar/benchmark.wasm
+
+  No difference in performance.
+
+  [93674620 133889868.00 183640420] tmp/wasmtime_main.so
+  [106974240 122942228.00 152750560] wasmtime/target/release/libwasmtime_bench_api.so

bench_res/first_impl.txt

@@ -0,0 +1,746 @@
+
+execution :: cycles :: benchmarks/hex-simd/benchmark.wasm
+
+  Δ = 345792.24 ± 11833.61 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 7.36x to 7.81x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [47340 52501.32 190872] tmp/wasmtime_main.so
+  [365580 398293.56 542808] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-base64/benchmark.wasm
+
+  Δ = 1970853027.76 ± 6979113.24 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 5.72x to 5.76x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [409600548 415637278.00 500391972] tmp/wasmtime_main.so
+  [2366821945 2386490305.76 2513644956] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-seqhash/benchmark.wasm
+
+  Δ = 46825190455.59 ± 127821876.94 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 5.61x to 5.63x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [9956663856 10133140692.71 10544512428] tmp/wasmtime_main.so
+  [56352845593 56958331148.30 58657017995] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/meshoptimizer/benchmark.wasm
+
+  Δ = 20106010623.89 ± 139125939.44 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 5.00x to 5.06x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [4815750421 4986455753.06 5219471557] tmp/wasmtime_main.so
+  [24698961323 25092466376.95 28372067424] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/blake3-scalar/benchmark.wasm
+
+  Δ = 1575653.08 ± 47716.10 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.89x to 5.14x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [368532 392537.50 565414] tmp/wasmtime_main.so
+  [1832400 1968190.58 3389364] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-xchacha20/benchmark.wasm
+
+  Δ = 24043961.50 ± 125310.65 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.86x to 4.91x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [5992344 6189280.03 8772444] tmp/wasmtime_main.so
+  [29597724 30233241.53 31265100] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/intgemm-simd/benchmark.wasm
+
+  Δ = 11790836237.58 ± 49258123.99 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.77x to 4.80x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [3095937432 3117382542.95 3205026611] tmp/wasmtime_main.so
+  [14643634139 14908218780.53 15634756441] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/blake3-simd/benchmark.wasm
+
+  Δ = 1519308.88 ± 43278.47 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.60x to 4.81x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [387108 410404.35 723458] tmp/wasmtime_main.so
+  [1825704 1929713.23 2913948] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/regex/benchmark.wasm
+
+  Δ = 881482054.62 ± 3682662.85 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.56x to 4.59x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [243603396 246887000.62 255784177] tmp/wasmtime_main.so
+  [1114811388 1128369055.24 1169802000] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/bz2/benchmark.wasm
+
+  Δ = 357450293.22 ± 1549780.77 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.37x to 4.40x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [103914719 105636434.33 114783229] tmp/wasmtime_main.so
+  [457542179 463086727.55 486926532] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-xblabla20/benchmark.wasm
+
+  Δ = 11882263.43 ± 71185.74 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.29x to 4.33x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [3426984 3590238.35 4005036] tmp/wasmtime_main.so
+  [15081912 15472501.78 16709212] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-gimli/benchmark.wasm
+
+  Δ = 18851736.16 ± 108983.69 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.27x to 4.31x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [5576796 5731722.69 6796368] tmp/wasmtime_main.so
+  [24021649 24583458.85 26077788] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-ratelimit/benchmark.wasm
+
+  Δ = 153466317.39 ± 987719.38 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 4.09x to 4.13x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [47873412 49380867.56 51816349] tmp/wasmtime_main.so
+  [198883511 202847184.95 230991985] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-sieve/benchmark.wasm
+
+  Δ = 2917751368.96 ± 57306722.93 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 3.89x to 4.01x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [909005867 990025561.72 1153883089] tmp/wasmtime_main.so
+  [3782853326 3907776930.68 5243343479] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-keccak/benchmark.wasm
+
+  Δ = 119732620.34 ± 7294642.74 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 3.70x to 4.05x faster than tmp/wasmtime_main.so!
+
+  [147621024 161371775.17 242314921] tmp/wasmtime_main.so
+  [34151940 41639154.83 84386880] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/blind-sig/benchmark.wasm
+
+  Δ = 761849961.52 ± 2634639.77 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 3.42x to 3.44x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [307939679 313264599.69 338735987] tmp/wasmtime_main.so
+  [1066340736 1075114561.21 1133205407] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-ctype/benchmark.wasm
+
+  Δ = 2051594010.51 ± 10906506.10 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 3.27x to 3.29x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [889577173 899301369.62 941784589] tmp/wasmtime_main.so
+  [2911972285 2950895380.13 3124423188] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-ed25519/benchmark.wasm
+
+  Δ = 26578151841.89 ± 149545429.75 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 3.22x to 3.25x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [11730048733 11882966637.26 14017886712] tmp/wasmtime_main.so
+  [37780663608 38461118479.15 40601000196] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/spidermonkey/benchmark.wasm
+
+  Δ = 2276822920.39 ± 18631445.19 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 3.13x to 3.16x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [1043458487 1062503164.66 1125259668] tmp/wasmtime_main.so
+  [3268311912 3339326085.05 3827897531] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-heapsort/benchmark.wasm
+
+  Δ = 6602600891.49 ± 27508477.21 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 2.92x to 2.94x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [3407309028 3425050525.40 3470297579] tmp/wasmtime_main.so
+  [9912739643 10027651416.89 10301668992] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-ed25519/benchmark.wasm
+
+  Δ = 288104513.37 ± 9735499.60 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 2.81x to 2.94x faster than tmp/wasmtime_main.so!
+
+  [418829472 441878125.69 536600161] tmp/wasmtime_main.so
+  [138407509 153773612.32 240393780] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-keccak/benchmark.wasm
+
+  Δ = 58212400.30 ± 1705214.89 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 2.81x to 2.92x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [29494764 31245282.73 47847564] tmp/wasmtime_main.so
+  [83949804 89457683.03 119340505] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-minicsv/benchmark.wasm
+
+  Δ = 3205249194.33 ± 18911258.58 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 2.69x to 2.71x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [1851027229 1882842939.40 1942785576] tmp/wasmtime_main.so
+  [5022056881 5088092133.73 5357629800] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-matrix/benchmark.wasm
+
+  Δ = 1231745436.50 ± 5707664.58 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 2.65x to 2.67x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [735814657 741951718.69 767631096] tmp/wasmtime_main.so
+  [1958603184 1973697155.19 2110201200] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/pulldown-cmark/benchmark.wasm
+
+  Δ = 11897294.54 ± 122079.69 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 2.41x to 2.44x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [8045424 8373467.87 10410839] tmp/wasmtime_main.so
+  [18899892 20270762.41 21215088] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-switch/benchmark.wasm
+
+  Δ = 204609415.39 ± 1598010.13 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 2.40x to 2.42x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [142621019 145191091.72 152865612] tmp/wasmtime_main.so
+  [342664380 349800507.11 374884265] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-fib2/benchmark.wasm
+
+  Δ = 3236916155.06 ± 31613056.68 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.89x to 1.91x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [3467702447 3591461293.98 3742357248] tmp/wasmtime_main.so
+  [6737314536 6828377449.04 7322136227] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/bz2/benchmark.wasm
+
+  Δ = 128770793.59 ± 7597401.75 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.83x to 1.94x faster than tmp/wasmtime_main.so!
+
+  [253517005 274203142.89 353141172] tmp/wasmtime_main.so
+  [128667349 145432349.30 217816236] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-switch/benchmark.wasm
+
+  Δ = 56438333.94 ± 7491692.69 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.58x to 1.76x faster than tmp/wasmtime_main.so!
+
+  [128765772 140553794.72 224904593] tmp/wasmtime_main.so
+  [69970176 84115460.78 148415723] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-sieve/benchmark.wasm
+
+  Δ = 23774967.71 ± 6707285.75 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.33x to 1.59x faster than tmp/wasmtime_main.so!
+
+  [63403956 75258605.97 137083860] tmp/wasmtime_main.so
+  [40798729 51483638.26 112740804] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-seqhash/benchmark.wasm
+
+  Δ = 12569754.53 ± 7044529.04 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.20x to 1.71x faster than tmp/wasmtime_main.so!
+
+  [30574403 40371559.79 114436297] tmp/wasmtime_main.so
+  [20335572 27801805.26 96580117] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-fib2/benchmark.wasm
+
+  Δ = 23443643.25 ± 6736282.13 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.32x to 1.58x faster than tmp/wasmtime_main.so!
+
+  [65146465 75878581.65 138438253] tmp/wasmtime_main.so
+  [41823324 52434938.40 112445784] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-nestedloop/benchmark.wasm
+
+  Δ = 23131358.99 ± 7040047.00 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.31x to 1.58x faster than tmp/wasmtime_main.so!
+
+  [64246896 75196786.96 137354796] tmp/wasmtime_main.so
+  [41746068 52065427.97 115099595] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-random/benchmark.wasm
+
+  Δ = 22180731.35 ± 7399359.46 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.28x to 1.57x faster than tmp/wasmtime_main.so!
+
+  [64062720 74368751.23 143287308] tmp/wasmtime_main.so
+  [41346179 52188019.88 122821552] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-matrix/benchmark.wasm
+
+  Δ = 23690644.52 ± 6102793.29 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.30x to 1.52x faster than tmp/wasmtime_main.so!
+
+  [70124616 81369306.83 143019432] tmp/wasmtime_main.so
+  [47633327 57678662.31 117778860] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-ctype/benchmark.wasm
+
+  Δ = 22184906.81 ± 6133213.98 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.30x to 1.52x faster than tmp/wasmtime_main.so!
+
+  [66025727 76273529.68 133334568] tmp/wasmtime_main.so
+  [44490997 54088622.87 117528480] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-base64/benchmark.wasm
+
+  Δ = 24097448.13 ± 6012729.31 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.30x to 1.51x faster than tmp/wasmtime_main.so!
+
+  [73622664 83718801.21 143594028] tmp/wasmtime_main.so
+  [50266079 59621353.08 112276475] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-ratelimit/benchmark.wasm
+
+  Δ = 23856950.87 ± 6442900.19 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.29x to 1.50x faster than tmp/wasmtime_main.so!
+
+  [72478980 83870223.68 143493840] tmp/wasmtime_main.so
+  [48298068 60013272.81 120159900] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-ackermann/benchmark.wasm
+
+  Δ = 25699694.19 ± 6260900.16 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.29x to 1.48x faster than tmp/wasmtime_main.so!
+
+  [74991707 92036959.79 150451669] tmp/wasmtime_main.so
+  [50091336 66337265.60 124640460] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/blake3-simd/benchmark.wasm
+
+  Δ = 11917241.79 ± 6120474.86 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.13x to 1.41x faster than tmp/wasmtime_main.so!
+
+  [45112464 56382136.04 124882526] tmp/wasmtime_main.so
+  [35716282 44464894.25 91276271] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/meshoptimizer/benchmark.wasm
+
+  Δ = 18268175.66 ± 12995516.57 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.06x to 1.35x faster than tmp/wasmtime_main.so!
+
+  [90282564 106583377.46 172790496] tmp/wasmtime_main.so
+  [68407524 88315201.80 509777639] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/blake3-simd/benchmark.wasm
+
+  Δ = 27081.34 ± 12431.92 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.11x to 1.29x faster than tmp/wasmtime_main.so!
+
+  [130644 165156.84 363528] tmp/wasmtime_main.so
+  [104508 138075.50 262080] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/regex/benchmark.wasm
+
+  Δ = 168480153.80 ± 16692141.15 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.17x to 1.21x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [814605301 881137381.33 1113401592] tmp/wasmtime_main.so
+  [986134213 1049617535.13 1163637937] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/regex/benchmark.wasm
+
+  Δ = 75630.26 ± 29814.65 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.08x to 1.19x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [442296 542271.59 863567] tmp/wasmtime_main.so
+  [465264 617901.85 877788] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/intgemm-simd/benchmark.wasm
+
+  Δ = 66461228.45 ± 8191971.57 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.12x to 1.15x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [447294061 482654101.73 581954652] tmp/wasmtime_main.so
+  [515086921 549115330.18 605796372] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-xchacha20/benchmark.wasm
+
+  Δ = 17534.86 ± 16060.09 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.01x to 1.25x faster than tmp/wasmtime_main.so!
+
+  [107316 153205.19 385056] tmp/wasmtime_main.so
+  [91044 135670.33 278172] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-xblabla20/benchmark.wasm
+
+  Δ = 17051.40 ± 14734.77 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.02x to 1.23x faster than tmp/wasmtime_main.so!
+
+  [107388 153577.80 470376] tmp/wasmtime_main.so
+  [89028 136526.40 303156] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/spidermonkey/benchmark.wasm
+
+  Δ = 943126119.95 ± 164284193.32 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.08x to 1.12x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [9021892788 9599833086.61 11546087076] tmp/wasmtime_main.so
+  [9978139369 10542959206.56 11402534341] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-sieve/benchmark.wasm
+
+  Δ = 15852.97 ± 11475.80 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.03x to 1.16x faster than tmp/wasmtime_main.so!
+
+  [147888 182349.73 321804] tmp/wasmtime_main.so
+  [134604 166496.76 312156] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-ackermann/benchmark.wasm
+
+  Δ = 17296.92 ± 15752.90 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.01x to 1.18x faster than tmp/wasmtime_main.so!
+
+  [164268 205161.84 472392] tmp/wasmtime_main.so
+  [144648 187864.92 385272] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/blake3-scalar/benchmark.wasm
+
+  Δ = 19482138.65 ± 6431347.52 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.06x to 1.12x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [199113301 217289885.09 288788372] tmp/wasmtime_main.so
+  [220745124 236772023.74 306132408] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-ctype/benchmark.wasm
+
+  Δ = 14145.49 ± 10664.87 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.02x to 1.14x faster than tmp/wasmtime_main.so!
+
+  [148536 187047.01 297001] tmp/wasmtime_main.so
+  [140796 172901.52 304200] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-fib2/benchmark.wasm
+
+  Δ = 13499.29 ± 13201.25 (confidence = 99%)
+
+  wasmtime/target/release/libwasmtime_bench_api.so is 1.00x to 1.16x faster than tmp/wasmtime_main.so!
+
+  [152316 184395.97 362197] tmp/wasmtime_main.so
+  [131760 170896.68 335880] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/hex-simd/benchmark.wasm
+
+  Δ = 14701654.36 ± 7722355.67 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.03x to 1.11x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [187211376 205180475.08 282106044] tmp/wasmtime_main.so
+  [198510264 219882129.44 284877252] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-memmove/benchmark.wasm
+
+  Δ = 2750310.45 ± 142406.89 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.07x to 1.07x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [38182931 39016919.77 40971169] tmp/wasmtime_main.so
+  [41085541 41767230.22 42774553] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-random/benchmark.wasm
+
+  Δ = 36038424.04 ± 857900.63 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.05x to 1.05x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [669296593 673652082.43 682587649] tmp/wasmtime_main.so
+  [705019320 709690506.47 716079853] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/pulldown-cmark/benchmark.wasm
+
+  Δ = 16340886.19 ± 7483652.81 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.02x to 1.06x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [365185836 401650579.46 470100098] tmp/wasmtime_main.so
+  [392953752 417991465.65 484354441] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/blind-sig/benchmark.wasm
+
+  Δ = 20118786.07 ± 13423183.44 (confidence = 99%)
+
+  tmp/wasmtime_main.so is 1.01x to 1.06x faster than wasmtime/target/release/libwasmtime_bench_api.so!
+
+  [515765845 573135907.05 772132716] tmp/wasmtime_main.so
+  [550619425 593254693.12 704204705] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-ackermann/benchmark.wasm
+
+  No difference in performance.
+
+  [504 2611.08 183780] tmp/wasmtime_main.so
+  [540 751.68 1296] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-gimli/benchmark.wasm
+
+  No difference in performance.
+
+  [7092684 15453006.13 84934656] tmp/wasmtime_main.so
+  [5726555 10028783.61 45153864] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-switch/benchmark.wasm
+
+  No difference in performance.
+
+  [149832 238550.40 6512688] tmp/wasmtime_main.so
+  [134496 170645.40 450072] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-xchacha20/benchmark.wasm
+
+  No difference in performance.
+
+  [24658307 35091571.34 110428560] tmp/wasmtime_main.so
+  [19204344 28347037.36 97184879] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/bz2/benchmark.wasm
+
+  No difference in performance.
+
+  [188748 273112.54 5585866] tmp/wasmtime_main.so
+  [186048 224155.80 456408] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-memmove/benchmark.wasm
+
+  No difference in performance.
+
+  [24383809 34604974.24 110344320] tmp/wasmtime_main.so
+  [19233251 28705933.78 97765704] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-xblabla20/benchmark.wasm
+
+  No difference in performance.
+
+  [24109811 35190977.32 111999528] tmp/wasmtime_main.so
+  [19003032 29830501.31 108302112] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-heapsort/benchmark.wasm
+
+  No difference in performance.
+
+  [25825104 36284578.84 98705267] tmp/wasmtime_main.so
+  [20983716 31298895.22 81193032] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/shootout-minicsv/benchmark.wasm
+
+  No difference in performance.
+
+  [10303488 19091732.71 95030243] tmp/wasmtime_main.so
+  [9972324 17266338.21 86076144] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/noop/benchmark.wasm
+
+  No difference in performance.
+
+  [94788 124173.74 283140] tmp/wasmtime_main.so
+  [85608 113814.01 316476] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-nestedloop/benchmark.wasm
+
+  No difference in performance.
+
+  [126900 173581.19 297072] tmp/wasmtime_main.so
+  [105984 159178.68 334008] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-matrix/benchmark.wasm
+
+  No difference in performance.
+
+  [151956 181208.16 367992] tmp/wasmtime_main.so
+  [142164 167950.09 523081] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-memmove/benchmark.wasm
+
+  No difference in performance.
+
+  [107568 151283.52 417996] tmp/wasmtime_main.so
+  [96552 140387.04 551844] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-keccak/benchmark.wasm
+
+  No difference in performance.
+
+  [104436 161983.80 325260] tmp/wasmtime_main.so
+  [90216 150572.50 284940] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-seqhash/benchmark.wasm
+
+  No difference in performance.
+
+  [133848 161197.20 268956] tmp/wasmtime_main.so
+  [122652 152241.84 404784] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-minicsv/benchmark.wasm
+
+  No difference in performance.
+
+  [130500 156812.06 297000] tmp/wasmtime_main.so
+  [120384 148217.39 255168] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-ed25519/benchmark.wasm
+
+  No difference in performance.
+
+  [145584 173084.40 341136] tmp/wasmtime_main.so
+  [135252 165701.52 326484] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/blake3-scalar/benchmark.wasm
+
+  No difference in performance.
+
+  [184392 212838.50 532908] tmp/wasmtime_main.so
+  [165528 203829.85 354708] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/hex-simd/benchmark.wasm
+
+  No difference in performance.
+
+  [209052 273107.88 423720] tmp/wasmtime_main.so
+  [187704 261877.34 427392] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-random/benchmark.wasm
+
+  No difference in performance.
+
+  [145620 177143.04 297648] tmp/wasmtime_main.so
+  [135648 169880.05 291132] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/blind-sig/benchmark.wasm
+
+  No difference in performance.
+
+  [192348 226756.79 469619] tmp/wasmtime_main.so
+  [182232 217715.76 380268] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-base64/benchmark.wasm
+
+  No difference in performance.
+
+  [149328 174356.64 295560] tmp/wasmtime_main.so
+  [138492 167680.81 302436] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/intgemm-simd/benchmark.wasm
+
+  No difference in performance.
+
+  [178056 207135.36 320040] tmp/wasmtime_main.so
+  [167760 200227.68 337680] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/noop/benchmark.wasm
+
+  No difference in performance.
+
+  [432 615.96 1008] tmp/wasmtime_main.so
+  [396 637.20 1116] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/meshoptimizer/benchmark.wasm
+
+  No difference in performance.
+
+  [179676 212660.64 351072] tmp/wasmtime_main.so
+  [167292 219323.16 435815] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-ratelimit/benchmark.wasm
+
+  No difference in performance.
+
+  [140976 172092.24 285480] tmp/wasmtime_main.so
+  [135180 167450.04 334512] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/spidermonkey/benchmark.wasm
+
+  No difference in performance.
+
+  [579672 632428.92 826056] tmp/wasmtime_main.so
+  [545976 645584.76 1196496] wasmtime/target/release/libwasmtime_bench_api.so
+
+compilation :: cycles :: benchmarks/noop/benchmark.wasm
+
+  No difference in performance.
+
+  [17553708 26606839.96 100542240] tmp/wasmtime_main.so
+  [18061812 26108957.05 84559104] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/pulldown-cmark/benchmark.wasm
+
+  No difference in performance.
+
+  [237672 275609.15 440675] tmp/wasmtime_main.so
+  [215172 279336.61 616680] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-heapsort/benchmark.wasm
+
+  No difference in performance.
+
+  [130644 158666.76 299736] tmp/wasmtime_main.so
+  [121464 157300.20 329328] wasmtime/target/release/libwasmtime_bench_api.so
+
+instantiation :: cycles :: benchmarks/shootout-gimli/benchmark.wasm
+
+  No difference in performance.
+
+  [84456 123928.57 425556] tmp/wasmtime_main.so
+  [86580 122936.41 249768] wasmtime/target/release/libwasmtime_bench_api.so
+
+execution :: cycles :: benchmarks/shootout-nestedloop/benchmark.wasm
+
+  No difference in performance.
+
+  [468 739.08 1476] tmp/wasmtime_main.so
+  [468 736.56 2700] wasmtime/target/release/libwasmtime_bench_api.so

fuzz/fuzz_targets/ion.rs

@@ -11,6 +11,6 @@ fuzz_target!(|func: Func| {
     let _ = env_logger::try_init();
     log::trace!("func:\n{:?}", func);
     let env = regalloc2::fuzzing::func::machine_env();
-    let _out =
-        regalloc2::fuzzing::ion::run(&func, &env, false, false).expect("regalloc did not succeed");
+    let _out = regalloc2::fuzzing::ion::run(&func, &env, false, false, true)
+        .expect("regalloc did not succeed");
 });

fuzz/fuzz_targets/ion_checker.rs

@@ -40,8 +40,8 @@ fuzz_target!(|testcase: TestCase| {
     let _ = env_logger::try_init();
     log::trace!("func:\n{:?}", func);
     let env = regalloc2::fuzzing::func::machine_env();
-    let out =
-        regalloc2::fuzzing::ion::run(&func, &env, true, false).expect("regalloc did not succeed");
+    let out = regalloc2::fuzzing::ion::run(&func, &env, true, false, true)
+        .expect("regalloc did not succeed");
 
     let mut checker = Checker::new(&func, &env);
     checker.prepare(&out);

fuzz/fuzz_targets/ssagen.rs

@@ -37,6 +37,6 @@ impl Arbitrary<'_> for TestCase {
 }
 
 fuzz_target!(|t: TestCase| {
-    let cfginfo = CFGInfo::new(&t.f).expect("could not create CFG info");
+    let cfginfo = CFGInfo::new(&t.f, true).expect("could not create CFG info");
     validate_ssa(&t.f, &cfginfo).expect("invalid SSA");
 });

src/cfg.rs

@@ -33,7 +33,7 @@ pub struct CFGInfo {
 }
 
 impl CFGInfo {
-    pub fn new<F: Function>(f: &F) -> Result<CFGInfo, RegAllocError> {
+    pub fn new<F: Function>(f: &F, needs_loop_depth: bool) -> Result<CFGInfo, RegAllocError> {
         let postorder = postorder::calculate(f.num_blocks(), f.entry_block(), |block| {
             f.block_succs(block)
         });
@@ -98,22 +98,24 @@ impl CFGInfo {
         }
 
         let mut approx_loop_depth = vec![];
-        let mut backedge_stack: SmallVec<[usize; 4]> = smallvec![];
-        let mut cur_depth = 0;
-        for block in 0..f.num_blocks() {
-            if backedge_in[block] > 0 {
-                cur_depth += 1;
-                backedge_stack.push(backedge_in[block]);
-            }
+        if needs_loop_depth {
+            let mut backedge_stack: SmallVec<[usize; 4]> = smallvec![];
+            let mut cur_depth = 0;
+            for block in 0..f.num_blocks() {
+                if backedge_in[block] > 0 {
+                    cur_depth += 1;
+                    backedge_stack.push(backedge_in[block]);
+                }
 
-            approx_loop_depth.push(cur_depth);
+                approx_loop_depth.push(cur_depth);
 
-            while backedge_stack.len() > 0 && backedge_out[block] > 0 {
-                backedge_out[block] -= 1;
-                *backedge_stack.last_mut().unwrap() -= 1;
-                if *backedge_stack.last().unwrap() == 0 {
-                    cur_depth -= 1;
-                    backedge_stack.pop();
+                while backedge_stack.len() > 0 && backedge_out[block] > 0 {
+                    backedge_out[block] -= 1;
+                    *backedge_stack.last_mut().unwrap() -= 1;
+                    if *backedge_stack.last().unwrap() == 0 {
+                        cur_depth -= 1;
+                        backedge_stack.pop();
+                    }
                 }
             }
         }

src/ion/data_structures.rs

@@ -686,3 +686,34 @@ pub fn u64_key(b: u32, a: u32) -> u64 {
 pub fn u128_key(d: u32, c: u32, b: u32, a: u32) -> u128 {
     a as u128 | (b as u128) << 32 | (c as u128) << 64 | (d as u128) << 96
 }
+
+pub struct Bitmap {
+    storage: SmallVec<[u64; 2]>,
+}
+
+impl Bitmap {
+    pub fn init(entry_count: usize) -> Self {
+        let u64_count = (entry_count + 63) / 64;
+        let mut storage = SmallVec::<[u64; 2]>::with_capacity(u64_count);
+        storage.resize(u64_count, 0);
+        Self { storage }
+    }
+
+    pub fn set(&mut self, idx: usize) {
+        let storage_idx = idx / 64;
+        let bit = 1u64 << (idx % 64);
+        self.storage[storage_idx] |= bit;
+    }
+
+    pub fn un_set(&mut self, idx: usize) {
+        let storage_idx = idx / 64;
+        let bit = 1u64 << (idx % 64);
+        self.storage[storage_idx] &= !bit;
+    }
+
+    pub fn is_set(&mut self, idx: usize) -> bool {
+        let storage_idx = idx / 64;
+        let bit = 1u64 << (idx % 64);
+        (self.storage[storage_idx] & bit) != 0
+    }
+}

src/ion/fast_alloc.rs.bak

@@ -0,0 +1,594 @@
+use alloc::vec;
+use alloc::vec::Vec;
+use smallvec::{smallvec, SmallVec};
+
+use crate::{
+    cfg::CFGInfo, Allocation, Block, Edit, Function, Inst, MachineEnv, Operand, OperandConstraint,
+    OperandKind, OperandPos, Output, PReg, ProgPoint, RegAllocError, RegClass, SpillSlot, VReg,
+};
+
+#[derive(Clone, Copy)]
+struct VRegInfo {
+    pub stack_slot: Option<u32>,
+    pub alloc_at_inst: Inst,
+    pub cur_reg: Option<PReg>,
+}
+
+impl Default for VRegInfo {
+    fn default() -> Self {
+        Self {
+            stack_slot: None,
+            alloc_at_inst: Inst::invalid(),
+            cur_reg: None,
+        }
+    }
+}
+
+struct AllocState {
+    pub vregs: Vec<VRegInfo>,
+    pub preorder: Vec<Block>,
+    pub allocs: Vec<Allocation>,
+    pub inst_alloc_offsets: Vec<u32>,
+    pub edits: Vec<(ProgPoint, Edit)>,
+    pub cur_stack_slot_idx: u32,
+    pub safepoint_slots: Vec<(ProgPoint, Allocation)>,
+}
+
+impl AllocState {
+    pub fn init<F: Function>(func: &F) -> Self {
+        let mut vregs = Vec::with_capacity(func.num_vregs());
+        vregs.resize(func.num_vregs(), VRegInfo::default());
+
+        let mut inst_alloc_offsets = Vec::with_capacity(func.num_insts());
+        inst_alloc_offsets.resize(func.num_insts(), 0);
+
+        Self {
+            vregs,
+            preorder: Self::calc_preorder(func),
+            allocs: Vec::new(),
+            inst_alloc_offsets,
+            edits: Vec::new(),
+            cur_stack_slot_idx: 0,
+            safepoint_slots: Vec::new(),
+        }
+    }
+
+    fn calc_preorder<F: Function>(func: &F) -> Vec<Block> {
+        let entry = func.entry_block();
+        let mut ret = vec![entry];
+
+        struct State<'a> {
+            block: Block,
+            succs: &'a [Block],
+            next_succ: usize,
+        }
+        let mut stack: SmallVec<[State; 64]> = smallvec![];
+
+        stack.push(State {
+            block: entry,
+            succs: func.block_succs(entry),
+            next_succ: 0,
+        });
+
+        while let Some(ref mut state) = stack.last_mut() {
+            if state.next_succ >= state.succs.len() {
+                stack.pop();
+                continue;
+            }
+
+            let block = state.succs[state.next_succ];
+            let succs = func.block_succs(block);
+            ret.push(block);
+
+            state.next_succ += 1;
+            if state.next_succ >= state.succs.len() {
+                stack.pop();
+            }
+
+            if !succs.is_empty() {
+                stack.push(State {
+                    block,
+                    succs: func.block_succs(block),
+                    next_succ: 0,
+                });
+            }
+        }
+
+        ret
+    }
+}
+
+pub fn run<F: Function>(
+    func: &F,
+    mach_env: &MachineEnv,
+    cfg: CFGInfo,
+) -> Result<Output, RegAllocError> {
+    let mut state = AllocState::init(func);
+
+    let reg_order_int = {
+        let class = RegClass::Int as usize;
+        let amount = mach_env.preferred_regs_by_class[class].len()
+            + mach_env.non_preferred_regs_by_class[class].len();
+        let mut reg_order = Vec::with_capacity(amount);
+        reg_order.extend_from_slice(&mach_env.preferred_regs_by_class[class]);
+        reg_order.extend_from_slice(&mach_env.non_preferred_regs_by_class[class]);
+        reg_order
+    };
+
+    let reg_order_float = {
+        let class = RegClass::Float as usize;
+        let amount = mach_env.preferred_regs_by_class[class].len()
+            + mach_env.non_preferred_regs_by_class[class].len();
+        let mut reg_order = Vec::with_capacity(amount);
+        reg_order.extend_from_slice(&mach_env.preferred_regs_by_class[class]);
+        reg_order.extend_from_slice(&mach_env.non_preferred_regs_by_class[class]);
+        reg_order
+    };
+
+    let slot_size_int = func.spillslot_size(RegClass::Int) as u32;
+    let slot_size_float = func.spillslot_size(RegClass::Float) as u32;
+
+    // TODO: this currently does not handle multiple defs/uses of the same vreg properly
+
+    // TODO: move to AllocState, needs to also contain if this is a pseudo-preg and refers to the stack
+    let mut preg_state: Vec<VReg> = Vec::with_capacity(PReg::NUM_INDEX);
+    preg_state.resize(PReg::NUM_INDEX, VReg::invalid());
+
+    for block in &state.preorder {
+        for inst in func.block_insns(*block).iter() {
+            let operands = func.inst_operands(inst);
+            let alloc_idx = state.allocs.len();
+            state.inst_alloc_offsets[inst.index()] = alloc_idx as u32;
+
+            state
+                .allocs
+                .resize(alloc_idx + operands.len(), Allocation::none());
+
+            // both of these smallvecs could hold 16 entries
+            // late uses may not be chosen as a target for writes
+            let mut late_use_regs: SmallVec<[PReg; 4]> = smallvec![];
+            let mut early_write_regs: SmallVec<[PReg; 4]> = smallvec![];
+
+            // TODO: wouldnt need this if we look up the inst a vreg was allocated at
+            let mut regs_allocated: SmallVec<[PReg; 8]> = smallvec![];
+
+            let mut cur_idx_int = 0;
+            let mut cur_idx_float = 0;
+            let mut has_early_write = false;
+
+            // allocate uses; fixed reg first, then the others
+            for (i, op) in operands.iter().enumerate() {
+                if op.kind() != OperandKind::Use {
+                    if op.pos() != OperandPos::Early {
+                        continue;
+                    }
+                    has_early_write = true;
+                }
+
+                let vreg = op.vreg();
+
+                match op.constraint() {
+                    OperandConstraint::Any | OperandConstraint::Reg | OperandConstraint::Stack => {
+                        continue
+                    }
+                    OperandConstraint::FixedReg(reg) => {
+                        if preg_state[reg.index()] != VReg::invalid()
+                            && preg_state[reg.index()] != vreg
+                        {
+                            return Err(RegAllocError::TooManyLiveRegs);
+                        }
+
+                        state.allocs[alloc_idx + i] = Allocation::reg(reg);
+                        preg_state[reg.index()] = vreg;
+                        state.vregs[vreg.vreg()].alloc_at_inst = inst;
+                        state.vregs[vreg.vreg()].cur_reg = Some(reg);
+                        regs_allocated.push(reg);
+                        if op.pos() == OperandPos::Late {
+                            late_use_regs.push(reg);
+                        }
+
+                        if op.kind() == OperandKind::Use {
+                            // Early Defs do not need to be moved
+                            match state.vregs[vreg.vreg()].stack_slot {
+                                Some(slot) => {
+                                    state.edits.push((
+                                        ProgPoint::before(inst),
+                                        Edit::Move {
+                                            from: Allocation::stack(SpillSlot::new(slot as usize)),
+                                            to: Allocation::reg(reg),
+                                        },
+                                    ));
+                                }
+                                None => {
+                                    return Err(RegAllocError::SSA(vreg, inst));
+                                }
+                            }
+                        } else {
+                            early_write_regs.push(reg);
+                            let slot = match state.vregs[vreg.vreg()].stack_slot {
+                                Some(slot) => slot,
+                                None => {
+                                    let size = if op.class() == RegClass::Int {
+                                        slot_size_int
+                                    } else {
+                                        slot_size_float
+                                    };
+                                    let slot = state.cur_stack_slot_idx;
+                                    state.cur_stack_slot_idx += size;
+                                    state.vregs[vreg.vreg()].stack_slot = Some(slot);
+                                    slot
+                                }
+                            };
+                            state.edits.push((
+                                ProgPoint::after(inst),
+                                Edit::Move {
+                                    from: Allocation::reg(reg),
+                                    to: Allocation::stack(SpillSlot::new(slot as usize)),
+                                },
+                            ));
+                        }
+                    }
+                    OperandConstraint::Reuse(_) => panic!("Reuse constraint for Use/Early-Write"),
+                }
+            }
+
+            for (i, op) in operands.iter().enumerate() {
+                if op.kind() != OperandKind::Use {
+                    if op.pos() != OperandPos::Early {
+                        continue;
+                    }
+                    continue;
+                }
+
+                let vreg = op.vreg();
+                let vreg_idx = vreg.vreg();
+
+                match op.constraint() {
+                    OperandConstraint::Stack => {
+                        // values need to be on stack already
+                        match state.vregs[vreg_idx].stack_slot {
+                            Some(slot) => {
+                                state.allocs[alloc_idx + i] =
+                                    Allocation::stack(SpillSlot::new(slot as usize));
+                            }
+                            None => {
+                                if op.kind() == OperandKind::Use {
+                                    return Err(RegAllocError::SSA(vreg, inst));
+                                }
+                                // alloc stack slot
+                                let size = if op.class() == RegClass::Int {
+                                    slot_size_int
+                                } else {
+                                    slot_size_float
+                                };
+                                let slot = state.cur_stack_slot_idx;
+                                state.cur_stack_slot_idx += size;
+                                state.allocs[alloc_idx + i] =
+                                    Allocation::stack(SpillSlot::new(slot as usize));
+                                state.vregs[vreg_idx].stack_slot = Some(slot);
+                            }
+                        }
+                    }
+                    // TODO: do any on stack?
+                    OperandConstraint::Any | OperandConstraint::Reg => {
+                        // check if vreg has been allocated before
+                        let mut alloc = None;
+                        for (j, op) in operands.iter().enumerate() {
+                            if j >= i {
+                                break;
+                            }
+
+                            if op.vreg() == vreg {
+                                alloc = Some(state.allocs[alloc_idx + j].clone());
+                                break;
+                            }
+                        }
+
+                        if let Some(a) = alloc {
+                            state.allocs[alloc_idx + i] = a;
+                            continue;
+                        }
+
+                        // find first non-allocated register
+                        let reg_order = if op.class() == RegClass::Int {
+                            &reg_order_int
+                        } else {
+                            &reg_order_float
+                        };
+                        let reg_order_idx = if op.class() == RegClass::Int {
+                            &mut cur_idx_int
+                        } else {
+                            &mut cur_idx_float
+                        };
+                        loop {
+                            if *reg_order_idx >= reg_order.len() {
+                                break;
+                            }
+
+                            if preg_state[reg_order[*reg_order_idx].index()] != VReg::invalid() {
+                                *reg_order_idx += 1;
+                                continue;
+                            }
+
+                            let reg = reg_order[*reg_order_idx];
+
+                            // TODO: helper func for alloc
+                            state.allocs[alloc_idx + i] = Allocation::reg(reg);
+                            preg_state[reg.index()] = vreg;
+                            state.vregs[vreg.vreg()].alloc_at_inst = inst;
+                            state.vregs[vreg.vreg()].cur_reg = Some(reg);
+                            regs_allocated.push(reg);
+                            if op.pos() == OperandPos::Late {
+                                late_use_regs.push(reg);
+                            }
+
+                            if op.kind() == OperandKind::Use {
+                                match state.vregs[vreg_idx].stack_slot {
+                                    Some(slot) => {
+                                        state.edits.push((
+                                            ProgPoint::before(inst),
+                                            Edit::Move {
+                                                from: Allocation::stack(SpillSlot::new(
+                                                    slot as usize,
+                                                )),
+                                                to: Allocation::reg(reg),
+                                            },
+                                        ));
+                                    }
+                                    None => {
+                                        return Err(RegAllocError::SSA(vreg, inst));
+                                    }
+                                }
+                            } else {
+                                early_write_regs.push(reg);
+                                let slot = match state.vregs[vreg.vreg()].stack_slot {
+                                    Some(slot) => slot,
+                                    None => {
+                                        let size = if op.class() == RegClass::Int {
+                                            slot_size_int
+                                        } else {
+                                            slot_size_float
+                                        };
+                                        let slot = state.cur_stack_slot_idx;
+                                        state.cur_stack_slot_idx += size;
+                                        state.vregs[vreg.vreg()].stack_slot = Some(slot);
+                                        slot
+                                    }
+                                };
+                                state.edits.push((
+                                    ProgPoint::after(inst),
+                                    Edit::Move {
+                                        from: Allocation::reg(reg),
+                                        to: Allocation::stack(SpillSlot::new(slot as usize)),
+                                    },
+                                ));
+                            }
+                        }
+
+                        // No register available
+                        // TODO: try to evict vreg that does not need to be in a preg
+                        if op.constraint() == OperandConstraint::Reg {
+                            return Err(RegAllocError::TooManyLiveRegs);
+                        }
+
+                        // any can live on the stack
+                        match state.vregs[vreg_idx].stack_slot {
+                            Some(slot) => {
+                                state.allocs[alloc_idx + i] =
+                                    Allocation::stack(SpillSlot::new(slot as usize));
+                            }
+                            None => {
+                                if op.kind() == OperandKind::Use {
+                                    return Err(RegAllocError::SSA(vreg, inst));
+                                }
+                                // alloc stack slot
+                                let size = if op.class() == RegClass::Int {
+                                    slot_size_int
+                                } else {
+                                    slot_size_float
+                                };
+                                let slot = state.cur_stack_slot_idx;
+                                state.cur_stack_slot_idx += size;
+                                state.allocs[alloc_idx + i] =
+                                    Allocation::stack(SpillSlot::new(slot as usize));
+                                state.vregs[vreg_idx].stack_slot = Some(slot);
+                            }
+                        }
+                    }
+                    OperandConstraint::FixedReg(_) => continue,
+                    OperandConstraint::Reuse(_) => unreachable!(),
+                }
+            }
+
+            // Handle writes
+            for (i, op) in operands.iter().enumerate() {
+                if op.kind() != OperandKind::Def || op.pos() == OperandPos::Early {
+                    continue;
+                }
+
+                let vreg = op.vreg();
+                let vreg_idx = vreg.vreg();
+
+                match op.constraint() {
+                    OperandConstraint::FixedReg(reg) => {
+                        let reg_idx = reg.index();
+
+                        if preg_state[reg_idx] != VReg::invalid() {
+                            // if the register is occupied by a late use we abort
+                            // TODO: move the allocation, if possible
+                            if late_use_regs.contains(&reg) || early_write_regs.contains(&reg) {
+                                todo!("trying to allocate fixed reg def on late use/early write");
+                            }
+
+                            // overwrite
+                            let vreg = preg_state[reg_idx].vreg();
+                            state.vregs[vreg].cur_reg = None;
+                        }
+
+                        preg_state[reg_idx] = vreg;
+                        state.vregs[vreg_idx].cur_reg = Some(reg);
+                        state.allocs[alloc_idx + i] = Allocation::reg(reg);
+
+                        match state.vregs[vreg_idx].stack_slot {
+                            None => {
+                                // alloc stack slot
+                                let size = if op.class() == RegClass::Int {
+                                    slot_size_int
+                                } else {
+                                    slot_size_float
+                                };
+                                let slot = state.cur_stack_slot_idx;
+                                state.cur_stack_slot_idx += size;
+                                state.vregs[vreg_idx].stack_slot = Some(slot);
+
+                                // move to stack after inst
+                                state.edits.push((
+                                    ProgPoint::after(inst),
+                                    Edit::Move {
+                                        from: Allocation::reg(reg),
+                                        to: Allocation::stack(SpillSlot::new(slot as usize)),
+                                    },
+                                ));
+                            }
+                            Some(_) => {
+                                return Err(RegAllocError::SSA(vreg, inst));
+                            }
+                        }
+                    }
+                    _ => continue,
+                }
+            }
+
+            cur_idx_int = 0;
+            cur_idx_float = 0;
+            for (i, op) in operands.iter().enumerate() {
+                if op.kind() != OperandKind::Def || op.pos() == OperandPos::Early {
+                    continue;
+                }
+
+                let vreg = op.vreg();
+                let vreg_idx = vreg.vreg();
+
+                match op.constraint() {
+                    OperandConstraint::Reg => {
+                        // find first non-allocated register
+                        let reg_order = if op.class() == RegClass::Int {
+                            &reg_order_int
+                        } else {
+                            &reg_order_float
+                        };
+                        let reg_order_idx = if op.class() == RegClass::Int {
+                            &mut cur_idx_int
+                        } else {
+                            &mut cur_idx_float
+                        };
+                        loop {
+                            if *reg_order_idx >= reg_order.len() {
+                                break;
+                            }
+                            let reg = reg_order[*reg_order_idx];
+
+                            if late_use_regs.contains(&reg) || early_write_regs.contains(&reg) {
+                                *reg_order_idx += 1;
+                                continue;
+                            }
+
+                            // remove allocated
+                            if preg_state[reg.index()] != VReg::invalid() {
+                                let vreg_idx = preg_state[reg.index()].vreg();
+                                state.vregs[vreg_idx].cur_reg = None;
+                            } else {
+                                regs_allocated.push(reg);
+                            }
+
+                            // TODO: helper func for alloc
+                            state.allocs[alloc_idx + i] = Allocation::reg(reg);
+                            preg_state[reg.index()] = vreg;
+                            state.vregs[vreg.vreg()].alloc_at_inst = inst;
+                            state.vregs[vreg.vreg()].cur_reg = Some(reg);
+
+                            // alloc stack slot
+                            let size = if op.class() == RegClass::Int {
+                                slot_size_int
+                            } else {
+                                slot_size_float
+                            };
+                            let slot = state.cur_stack_slot_idx;
+                            state.cur_stack_slot_idx += size;
+                            state.vregs[vreg_idx].stack_slot = Some(slot);
+
+                            match state.vregs[vreg_idx].stack_slot {
+                                Some(slot) => {
+                                    state.edits.push((
+                                        ProgPoint::after(inst),
+                                        Edit::Move {
+                                            from: Allocation::reg(reg),
+                                            to: Allocation::stack(SpillSlot::new(slot as usize)),
+                                        },
+                                    ));
+                                }
+                                None => {
+                                    return Err(RegAllocError::SSA(vreg, inst));
+                                }
+                            }
+                        }
+
+                        // No register available
+                        // TODO: try to evict vreg that does not need to be in a preg
+                        return Err(RegAllocError::TooManyLiveRegs);
+                    }
+                    OperandConstraint::Any | OperandConstraint::Stack => {
+                        // alloc stack slot
+                        let size = if op.class() == RegClass::Int {
+                            slot_size_int
+                        } else {
+                            slot_size_float
+                        };
+                        let slot = state.cur_stack_slot_idx;
+                        state.cur_stack_slot_idx += size;
+                        state.vregs[vreg_idx].stack_slot = Some(slot);
+                        state.allocs[alloc_idx + i] =
+                            Allocation::stack(SpillSlot::new(slot as usize));
+                    }
+                    OperandConstraint::Reuse(op_idx) => {
+                        let alloc = state.allocs[alloc_idx + op_idx];
+                        if alloc.is_none() || operands[op_idx].pos() == OperandPos::Late {
+                            panic!("Invalid reuse");
+                        }
+
+                        state.allocs[alloc_idx + i] = alloc;
+                        if let Some(alloc) = alloc.as_stack() {
+                            state.vregs[vreg_idx].stack_slot = Some(alloc.index() as u32);
+                            state.vregs[operands[op_idx].vreg().vreg()].stack_slot = None;
+                        } else if let Some(reg) = alloc.as_reg() {
+                            state.vregs[operands[op_idx].vreg().vreg()].cur_reg = None;
+                            state.vregs[vreg_idx].cur_reg = Some(reg);
+
+                            // alloc stack slot
+                            let size = if op.class() == RegClass::Int {
+                                slot_size_int
+                            } else {
+                                slot_size_float
+                            };
+                            let slot = state.cur_stack_slot_idx;
+                            state.cur_stack_slot_idx += size;
+                            state.vregs[vreg_idx].stack_slot = Some(slot);
+
+                            // move to stack after inst
+                            state.edits.push((
+                                ProgPoint::after(inst),
+                                Edit::Move {
+                                    from: Allocation::reg(reg),
+                                    to: Allocation::stack(SpillSlot::new(slot as usize)),
+                                },
+                            ));
+                        }
+                    }
+                    OperandConstraint::FixedReg(_) => continue,
+                }
+            }
+        }
+    }
+
+    todo!("")
+}

src/ion/mod.rs

@@ -36,6 +36,8 @@ pub(crate) mod process;
 use process::*;
 use smallvec::smallvec;
 pub(crate) mod dump;
+mod fast_alloc;
+mod fast_alloc2;
 pub(crate) mod moves;
 pub(crate) mod spill;
 pub(crate) mod stackmap;
@@ -120,14 +122,24 @@ pub fn run<F: Function>(
     mach_env: &MachineEnv,
     enable_annotations: bool,
     enable_ssa_checker: bool,
+    use_fast_alloc: bool,
 ) -> Result<Output, RegAllocError> {
-    let cfginfo = CFGInfo::new(func)?;
+    let mut cfginfo = None;
 
     if enable_ssa_checker {
-        validate_ssa(func, &cfginfo)?;
+        cfginfo = Some(CFGInfo::new(func, !use_fast_alloc)?);
+        validate_ssa(func, cfginfo.as_ref().unwrap())?;
     }
 
-    let mut env = Env::new(func, mach_env, cfginfo, enable_annotations);
+    if use_fast_alloc {
+        return fast_alloc::run(func, mach_env);
+    }
+
+    if cfginfo.is_none() {
+        cfginfo = Some(CFGInfo::new(func, !use_fast_alloc)?);
+    }
+
+    let mut env = Env::new(func, mach_env, cfginfo.take().unwrap(), enable_annotations);
     env.init()?;
 
     env.run()?;

src/lib.rs

@@ -1491,7 +1491,13 @@ pub fn run<F: Function>(
     env: &MachineEnv,
     options: &RegallocOptions,
 ) -> Result<Output, RegAllocError> {
-    ion::run(func, env, options.verbose_log, options.validate_ssa)
+    ion::run(
+        func,
+        env,
+        options.verbose_log,
+        options.validate_ssa,
+        options.fast_alloc,
+    )
 }
 
 /// Options for allocation.
@@ -1502,4 +1508,7 @@ pub struct RegallocOptions {
 
     /// Run the SSA validator before allocating registers.
     pub validate_ssa: bool,
+
+    /// Use a fast algorithm that may return suboptimal results.
+    pub fast_alloc: bool,
 }