From a8f53030d7f55da38d3ce6da86fe4063f4a122cc Mon Sep 17 00:00:00 2001 From: oxura Date: Sun, 11 Oct 2026 19:43:05 +0600 Subject: [PATCH 1/2] fix: spill wide segment arguments beyond the bounded call bank --- README.md | 4 + bend2/comp.ts | 72 +++--- tests/reg/wide_live_closure.bend | 325 ++++++++++++++++++++++++++ tests/reg/wide_live_continuation.bend | 24 ++ tests/reg/wide_live_fork.bend | 323 +++++++++++++++++++++++++ tests/reg/wide_native_spin.bend | 325 ++++++++++++++++++++++++++ 6 files changed, 1040 insertions(+), 33 deletions(-) create mode 100644 tests/reg/wide_live_closure.bend create mode 100644 tests/reg/wide_live_continuation.bend create mode 100644 tests/reg/wide_live_fork.bend create mode 100644 tests/reg/wide_native_spin.bend diff --git a/README.md b/README.md index 02737ec3e..745960b39 100644 --- a/README.md +++ b/README.md @@ -20,6 +20,10 @@ Thanks to strong types, purity and linearity, Bend compiles to fast executables as fast as hand-written C (single-core), and even faster (on 10000s cores). The entire language runs on the GPU, with full memory unification. +The C evaluator's shared call bank stays at 247 words. Wider segment +arguments spill to its stack, so closure captures and fork joins can keep +larger live sets without enlarging that bank. + ## Bend checks FAST **Target:** outperform every proof assistant by several OOMs. **Status:** diff --git a/bend2/comp.ts b/bend2/comp.ts index fa3f69f89..b3e1ad8bc 100644 --- a/bend2/comp.ts +++ b/bend2/comp.ts @@ -34,6 +34,7 @@ type Seg = { refs: Set; spin?: boolean; fork?: boolean; + native?: boolean; }; type Spine = { @@ -117,13 +118,10 @@ type Fun = { n: number; h: HTerm | null; live: Dom[]; lays: Lay[]; ret: Lay }; // Constants // ========= -// CLO_APPLY and IO_EMIT are the runtime's own segments, named with a ~ -// so that no file declares them. FOLD_FUEL caps the nodes that unfolds -// add to a segment, so a literal-bounded loop does not unroll into its -// caller. A spin of SPIN_FAR characters of C is a call on the device -// (DFAR). WIDE is the widest flat layout or segment; a node past -// it pads to its size class and keeps 240 plus log2 of it in CID_T. An -// argument nested past TPL_DEEP brackets goes to a local (clang allows 256). +// ~ reserves runtime segment names. FOLD_FUEL bounds unfolded nodes. +// SPIN_FAR bounds inline C characters on device. WIDE caps layouts/bank; +// excess live words spill. Wide CID_T entries encode 240+log2(size). +// TPL_DEEP avoids clang's 256-bracket limit. const CLO_APPLY = "Clo~apply"; @@ -1520,11 +1518,10 @@ function spare_flush(sc: Scope): void { // Seg // === -// A segment enters by popping its frame and reading its -// parameters from the frame slots, then from the bank (r0..). +// Pop the frame and register spill before opening the parameters. function seg_new(name: string, ret: Lay, params: string[], - ks: Kind[] = params.map(() => "w64"), frame: Seg["frame"] = null): Seg { + ks: Kind[] = [], frame: Seg["frame"] = null): Seg { return { fid: name && seg_fid(name), def: name, ret, lines: [], params, ks, frame, refs: new Set() }; } @@ -1533,11 +1530,17 @@ function seg_fid(k: Name): string { return name_id("FID_", k); } +function seg_reg(seg: Seg, i: number, offset = 0): string { + return !seg.native && i >= WIDE ? `STK(${offset + i - WIDE})` : `r${i}`; +} + function seg_take(seg: Seg): string[] { const { pop, at } = seg.frame ?? { pop: 0, at: [] }; - return [...pop > 0 ? [`WL_POPN(${pop});`] : [], ...seg.params.map((p, i) => + const drop = pop + (seg.native ? 0 + : Math.max(0, seg.params.length - at.length - WIDE)); + return [...drop > 0 ? [`WL_POPN(${drop});`] : [], ...seg.params.map((p, i) => `${lay_c(seg.ks[i])} ${p} = ${i < at.length ? `STK(${at[i]})` - : `r${i - at.length}`};`)]; + : seg_reg(seg, i - at.length, pop)};`)]; } function seg_text(lines: string[], tab: number): string[] { @@ -1572,9 +1575,9 @@ function seg_open(sc: Scope, name: string, ret: Lay, frame: Seg["frame"], } return nw; }), b.val.lay)); - const all = [...vals, res]; - const seg = seg_new(name, ret, all.flatMap((v) => v.ws), - all.flatMap((v) => v.lay.ks), frame); + vals.push(res); + const seg = seg_new(name, ret, vals.flatMap((v) => v.ws), + vals.flatMap((v) => v.lay.ks), frame); FL.segs.push(seg); sc = { ...sc, seg, spares: [], uses: new Map() }; live.forEach(([p, b], i) => bind_uses(sc, p, vals[i], rest, b.A, false)); @@ -2089,12 +2092,15 @@ function emit_jump(sc: Scope, args: string[], k: Name, bang?: boolean): void { file_push(sc, `return term_tsk(${fid}, ${ emit_task(sc, fid, 0, args)});`)); } - args.forEach((a, i) => file_push(sc, `r${i} = ${a};`)); + const spill = sc.seg.native ? 0 : Math.max(0, args.length - WIDE); + if (spill) file_push(sc, `WL_ROOM(${spill})`); + args.forEach((a, i) => file_push(sc, `${seg_reg(sc.seg, i)} = ${a};`)); if (sc.seg.def !== k) { + if (spill) file_push(sc, `WL_PUSHN(${spill});`); return file_push(sc, `WL_JMP(${seg_ref(sc, fid)});`); } sc.seg.spin = true; - sc.seg.params.forEach((p, i) => file_push(sc, `${p} = r${i};`)); + sc.seg.params.forEach((p, i) => file_push(sc, `${p} = ${seg_reg(sc.seg, i)};`)); file_push(sc, `WL_AGAIN(${sc.seg.fid});`); } @@ -2210,6 +2216,7 @@ function emit_native(sc: Scope, k: Name, ers: HTerm[]): string { const [sl, vals] = emit_open(sc, k); const seg = sl.seg; seg.fid = name; + seg.native = true; const dst = val_new(seg.ret.ks.map((_, j) => `o[${j}]`), seg.ret); emit_body(sl, fun_of(k).h!, FL.book.tlds[k].T, ers, vals, dst); FUEL = fuel; @@ -2771,11 +2778,9 @@ function effect_srcs(ext: string, miss: string): string[] { // C // - -// A segment may fork if one it reaches does; Clo~apply reaches every -// closure. The device holds what the bangs reach, and every closure when a -// bang's parameter may hold one. One bank serves both lanes: rp pads the -// host's twelfth slot, which keeps rax free for the tail call. WL_LOAD is a -// ladder, as clang builds the phi cascade of a fallthrough switch in O(n^2). +// The device holds bang-reachable segments and closure-taking bangs' closures. +// rp frees rax for host musttail. WL_LOAD's ladder avoids clang's quadratic +// phi cascade for a fallthrough switch. export function compile_book(book: Bend.Book): string { FL = file_new(book, false); @@ -2845,7 +2850,8 @@ export function compile_book(book: Bend.Book): string { const forky = graph_close(new Set(FL.segs.filter((s) => s.fork) .map((s) => s.fid)), [...FL.segs, { fid: seg_fid(CLO_APPLY), refs: FL.clos }].flatMap((s) => [...s.refs].map((r) => [r, s.fid]))); - if (entries.some((s) => s.params.length > WIDE) + if (entries.some((s) => s.params.length > WIDE && + def_foreign(FL.book.tlds[s.def])) || [...cids.values()].some((n) => n > 255)) { die("an arity over " + WIDE); } @@ -2856,9 +2862,9 @@ export function compile_book(book: Bend.Book): string { const resw = Math.max(...entries.map((s) => s.ret.ks.length)); const n = Math.max(resw, ...entries.filter((s) => s.frame === null) .map((s) => s.params.length)); - const rs = [...Array(n).keys()].map((i) => "r" + i); + const rs = [...Array(Math.min(n, WIDE)).keys()].map((i) => "r" + i); const ws = n > 6 ? [...rs.slice(0, 6), "rp", ...rs.slice(6)] : rs; - defs.push(`CONSTV u8 FID_T[][3] = { ${entries.map((s) => + defs.push(`CONSTV struct { u32 arity; u8 resw, flags; } FID_T[] = { ${entries.map((s) => `{ ${s.params.length}, ${s.frame === null ? 0 : s.params.length - s.frame.at.length}, ${Number(FL.bangs.has(s.def)) | Number(!forky.has(s.fid)) << 1} }`).join(", ")} };`, @@ -2869,9 +2875,10 @@ export function compile_book(book: Bend.Book): string { `#define WL_BANK Term ${ws.join(", ")};`, "", `#define WL_LOAD(A, N) \\\n do { \\\n${rs.map((r, i) => ` if ((N) <= ${i}) break; ${r} = e.mem[(A) + ${i}]; \\\n`).join("") - } } while (0);`, "", + } } while (0);${n > WIDE ? ` \\\n if ((N) > ${WIDE}) { \\\n WL_ROOM((N) - ${WIDE}) \\\n WL_ARGS((A) + ${WIDE}, (N) - ${WIDE} + 1) \\\n }` : ""}`, "", `#define WL_LAST(X) \\\n switch (war) { \\\n${rs.map((r, i) => - ` case ${i}: ${r} = (X); \\\n break; \\\n`).join("")} }`, "", + ` case ${i}: ${r} = (X); \\\n break; \\\n`).join("")}${n > WIDE + ? " default: WL_ROOM(1) STK(0) = (X); WL_PUSHN(1); \\\n" : ""} }`, "", `#define WL_SAVE(V) ${rs.slice(0, resw).map((r, j) => `(V)[${j}] = ${r};`).join(" ")}`, "", `#define WL_TAKE(V) ${rs.slice(0, resw).map((r, j) => @@ -3588,10 +3595,10 @@ ${tabs} #define TAB_AT(T, S, I) T[S < I ? S : I] -#define fid_arity(x) ((u32)FID_T[x][0]) -#define fid_resw(x) ((u32)FID_T[x][1]) -#define fid_bangs(x) ((bool)(FID_T[x][2] & 1)) -#define fid_nofk(x) ((bool)(FID_T[x][2] & 2)) +#define fid_arity(x) (FID_T[x].arity) +#define fid_resw(x) (FID_T[x].resw) +#define fid_bangs(x) ((bool)(FID_T[x].flags & 1)) +#define fid_nofk(x) ((bool)(FID_T[x].flags & 2)) #define cid_arity(x) ((u32)CID_T[x][0]) #define cid_hot(x) ((bool)CID_T[x][1]) @@ -4365,8 +4372,7 @@ static Term work_loop(Env e, DEV Term* sp, Term t, u32 seq) { // Segments // ======== -// A task enters through its words: a continuation's results ride r0.. -// and its parameters the stack; any other segment's parameters ride r0.. +// Parameters: continuation frames, otherwise the bank plus its spill tail. ${segs} diff --git a/tests/reg/wide_live_closure.bend b/tests/reg/wide_live_closure.bend new file mode 100644 index 000000000..a5ebdb39d --- /dev/null +++ b/tests/reg/wide_live_closure.bend @@ -0,0 +1,325 @@ +# All 300 captures survive a materialized callable wrapper. +import Base + +type Wrapped is Type: + Wrap{f: @+x:Nat -> Nat} + +def close(+s: String) -> Wrapped: + v0 = String.length(s ++ "0") + v1 = String.length(s ++ "1") + v2 = String.length(s ++ "2") + v3 = String.length(s ++ "3") + v4 = String.length(s ++ "4") + v5 = String.length(s ++ "5") + v6 = String.length(s ++ "6") + v7 = String.length(s ++ "7") + v8 = String.length(s ++ "8") + v9 = String.length(s ++ "9") + v10 = String.length(s ++ "10") + v11 = String.length(s ++ "11") + v12 = String.length(s ++ "12") + v13 = String.length(s ++ "13") + v14 = String.length(s ++ "14") + v15 = String.length(s ++ "15") + v16 = String.length(s ++ "16") + v17 = String.length(s ++ "17") + v18 = String.length(s ++ "18") + v19 = String.length(s ++ "19") + v20 = String.length(s ++ "20") + v21 = String.length(s ++ "21") + v22 = String.length(s ++ "22") + v23 = String.length(s ++ "23") + v24 = String.length(s ++ "24") + v25 = String.length(s ++ "25") + v26 = String.length(s ++ "26") + v27 = String.length(s ++ "27") + v28 = String.length(s ++ "28") + v29 = String.length(s ++ "29") + v30 = String.length(s ++ "30") + v31 = String.length(s ++ "31") + v32 = String.length(s ++ "32") + v33 = String.length(s ++ "33") + v34 = String.length(s ++ "34") + v35 = String.length(s ++ "35") + v36 = String.length(s ++ "36") + v37 = String.length(s ++ "37") + v38 = String.length(s ++ "38") + v39 = String.length(s ++ "39") + v40 = String.length(s ++ "40") + v41 = String.length(s ++ "41") + v42 = String.length(s ++ "42") + v43 = String.length(s ++ "43") + v44 = String.length(s ++ "44") + v45 = String.length(s ++ "45") + v46 = String.length(s ++ "46") + v47 = String.length(s ++ "47") + v48 = String.length(s ++ "48") + v49 = String.length(s ++ "49") + v50 = String.length(s ++ "50") + v51 = String.length(s ++ "51") + v52 = String.length(s ++ "52") + v53 = String.length(s ++ "53") + v54 = String.length(s ++ "54") + v55 = String.length(s ++ "55") + v56 = String.length(s ++ "56") + v57 = String.length(s ++ "57") + v58 = String.length(s ++ "58") + v59 = String.length(s ++ "59") + v60 = String.length(s ++ "60") + v61 = String.length(s ++ "61") + v62 = String.length(s ++ "62") + v63 = String.length(s ++ "63") + v64 = String.length(s ++ "64") + v65 = String.length(s ++ "65") + v66 = String.length(s ++ "66") + v67 = String.length(s ++ "67") + v68 = String.length(s ++ "68") + v69 = String.length(s ++ "69") + v70 = String.length(s ++ "70") + v71 = String.length(s ++ "71") + v72 = String.length(s ++ "72") + v73 = String.length(s ++ "73") + v74 = String.length(s ++ "74") + v75 = String.length(s ++ "75") + v76 = String.length(s ++ "76") + v77 = String.length(s ++ "77") + v78 = String.length(s ++ "78") + v79 = String.length(s ++ "79") + v80 = String.length(s ++ "80") + v81 = String.length(s ++ "81") + v82 = String.length(s ++ "82") + v83 = String.length(s ++ "83") + v84 = String.length(s ++ "84") + v85 = String.length(s ++ "85") + v86 = String.length(s ++ "86") + v87 = String.length(s ++ "87") + v88 = String.length(s ++ "88") + v89 = String.length(s ++ "89") + v90 = String.length(s ++ "90") + v91 = String.length(s ++ "91") + v92 = String.length(s ++ "92") + v93 = String.length(s ++ "93") + v94 = String.length(s ++ "94") + v95 = String.length(s ++ "95") + v96 = String.length(s ++ "96") + v97 = String.length(s ++ "97") + v98 = String.length(s ++ "98") + v99 = String.length(s ++ "99") + v100 = String.length(s ++ "100") + v101 = String.length(s ++ "101") + v102 = String.length(s ++ "102") + v103 = String.length(s ++ "103") + v104 = String.length(s ++ "104") + v105 = String.length(s ++ "105") + v106 = String.length(s ++ "106") + v107 = String.length(s ++ "107") + v108 = String.length(s ++ "108") + v109 = String.length(s ++ "109") + v110 = String.length(s ++ "110") + v111 = String.length(s ++ "111") + v112 = String.length(s ++ "112") + v113 = String.length(s ++ "113") + v114 = String.length(s ++ "114") + v115 = String.length(s ++ "115") + v116 = String.length(s ++ "116") + v117 = String.length(s ++ "117") + v118 = String.length(s ++ "118") + v119 = String.length(s ++ "119") + v120 = String.length(s ++ "120") + v121 = String.length(s ++ "121") + v122 = String.length(s ++ "122") + v123 = String.length(s ++ "123") + v124 = String.length(s ++ "124") + v125 = String.length(s ++ "125") + v126 = String.length(s ++ "126") + v127 = String.length(s ++ "127") + v128 = String.length(s ++ "128") + v129 = String.length(s ++ "129") + v130 = String.length(s ++ "130") + v131 = String.length(s ++ "131") + v132 = String.length(s ++ "132") + v133 = String.length(s ++ "133") + v134 = String.length(s ++ "134") + v135 = String.length(s ++ "135") + v136 = String.length(s ++ "136") + v137 = String.length(s ++ "137") + v138 = String.length(s ++ "138") + v139 = String.length(s ++ "139") + v140 = String.length(s ++ "140") + v141 = String.length(s ++ "141") + v142 = String.length(s ++ "142") + v143 = String.length(s ++ "143") + v144 = String.length(s ++ "144") + v145 = String.length(s ++ "145") + v146 = String.length(s ++ "146") + v147 = String.length(s ++ "147") + v148 = String.length(s ++ "148") + v149 = String.length(s ++ "149") + v150 = String.length(s ++ "150") + v151 = String.length(s ++ "151") + v152 = String.length(s ++ "152") + v153 = String.length(s ++ "153") + v154 = String.length(s ++ "154") + v155 = String.length(s ++ "155") + v156 = String.length(s ++ "156") + v157 = String.length(s ++ "157") + v158 = String.length(s ++ "158") + v159 = String.length(s ++ "159") + v160 = String.length(s ++ "160") + v161 = String.length(s ++ "161") + v162 = String.length(s ++ "162") + v163 = String.length(s ++ "163") + v164 = String.length(s ++ "164") + v165 = String.length(s ++ "165") + v166 = String.length(s ++ "166") + v167 = String.length(s ++ "167") + v168 = String.length(s ++ "168") + v169 = String.length(s ++ "169") + v170 = String.length(s ++ "170") + v171 = String.length(s ++ "171") + v172 = String.length(s ++ "172") + v173 = String.length(s ++ "173") + v174 = String.length(s ++ "174") + v175 = String.length(s ++ "175") + v176 = String.length(s ++ "176") + v177 = String.length(s ++ "177") + v178 = String.length(s ++ "178") + v179 = String.length(s ++ "179") + v180 = String.length(s ++ "180") + v181 = String.length(s ++ "181") + v182 = String.length(s ++ "182") + v183 = String.length(s ++ "183") + v184 = String.length(s ++ "184") + v185 = String.length(s ++ "185") + v186 = String.length(s ++ "186") + v187 = String.length(s ++ "187") + v188 = String.length(s ++ "188") + v189 = String.length(s ++ "189") + v190 = String.length(s ++ "190") + v191 = String.length(s ++ "191") + v192 = String.length(s ++ "192") + v193 = String.length(s ++ "193") + v194 = String.length(s ++ "194") + v195 = String.length(s ++ "195") + v196 = String.length(s ++ "196") + v197 = String.length(s ++ "197") + v198 = String.length(s ++ "198") + v199 = String.length(s ++ "199") + v200 = String.length(s ++ "200") + v201 = String.length(s ++ "201") + v202 = String.length(s ++ "202") + v203 = String.length(s ++ "203") + v204 = String.length(s ++ "204") + v205 = String.length(s ++ "205") + v206 = String.length(s ++ "206") + v207 = String.length(s ++ "207") + v208 = String.length(s ++ "208") + v209 = String.length(s ++ "209") + v210 = String.length(s ++ "210") + v211 = String.length(s ++ "211") + v212 = String.length(s ++ "212") + v213 = String.length(s ++ "213") + v214 = String.length(s ++ "214") + v215 = String.length(s ++ "215") + v216 = String.length(s ++ "216") + v217 = String.length(s ++ "217") + v218 = String.length(s ++ "218") + v219 = String.length(s ++ "219") + v220 = String.length(s ++ "220") + v221 = String.length(s ++ "221") + v222 = String.length(s ++ "222") + v223 = String.length(s ++ "223") + v224 = String.length(s ++ "224") + v225 = String.length(s ++ "225") + v226 = String.length(s ++ "226") + v227 = String.length(s ++ "227") + v228 = String.length(s ++ "228") + v229 = String.length(s ++ "229") + v230 = String.length(s ++ "230") + v231 = String.length(s ++ "231") + v232 = String.length(s ++ "232") + v233 = String.length(s ++ "233") + v234 = String.length(s ++ "234") + v235 = String.length(s ++ "235") + v236 = String.length(s ++ "236") + v237 = String.length(s ++ "237") + v238 = String.length(s ++ "238") + v239 = String.length(s ++ "239") + v240 = String.length(s ++ "240") + v241 = String.length(s ++ "241") + v242 = String.length(s ++ "242") + v243 = String.length(s ++ "243") + v244 = String.length(s ++ "244") + v245 = String.length(s ++ "245") + v246 = String.length(s ++ "246") + v247 = String.length(s ++ "247") + v248 = String.length(s ++ "248") + v249 = String.length(s ++ "249") + v250 = String.length(s ++ "250") + v251 = String.length(s ++ "251") + v252 = String.length(s ++ "252") + v253 = String.length(s ++ "253") + v254 = String.length(s ++ "254") + v255 = String.length(s ++ "255") + v256 = String.length(s ++ "256") + v257 = String.length(s ++ "257") + v258 = String.length(s ++ "258") + v259 = String.length(s ++ "259") + v260 = String.length(s ++ "260") + v261 = String.length(s ++ "261") + v262 = String.length(s ++ "262") + v263 = String.length(s ++ "263") + v264 = String.length(s ++ "264") + v265 = String.length(s ++ "265") + v266 = String.length(s ++ "266") + v267 = String.length(s ++ "267") + v268 = String.length(s ++ "268") + v269 = String.length(s ++ "269") + v270 = String.length(s ++ "270") + v271 = String.length(s ++ "271") + v272 = String.length(s ++ "272") + v273 = String.length(s ++ "273") + v274 = String.length(s ++ "274") + v275 = String.length(s ++ "275") + v276 = String.length(s ++ "276") + v277 = String.length(s ++ "277") + v278 = String.length(s ++ "278") + v279 = String.length(s ++ "279") + v280 = String.length(s ++ "280") + v281 = String.length(s ++ "281") + v282 = String.length(s ++ "282") + v283 = String.length(s ++ "283") + v284 = String.length(s ++ "284") + v285 = String.length(s ++ "285") + v286 = String.length(s ++ "286") + v287 = String.length(s ++ "287") + v288 = String.length(s ++ "288") + v289 = String.length(s ++ "289") + v290 = String.length(s ++ "290") + v291 = String.length(s ++ "291") + v292 = String.length(s ++ "292") + v293 = String.length(s ++ "293") + v294 = String.length(s ++ "294") + v295 = String.length(s ++ "295") + v296 = String.length(s ++ "296") + v297 = String.length(s ++ "297") + v298 = String.length(s ++ "298") + v299 = String.length(s ++ "299") + Wrap{x => Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.mul(v0, Nat.add(x, 0n)), Nat.mul(v1, Nat.add(x, 1n))), Nat.mul(v2, Nat.add(x, 2n))), Nat.mul(v3, Nat.add(x, 3n))), Nat.mul(v4, Nat.add(x, 4n))), Nat.mul(v5, Nat.add(x, 5n))), Nat.mul(v6, Nat.add(x, 6n))), Nat.mul(v7, Nat.add(x, 7n))), Nat.mul(v8, Nat.add(x, 8n))), Nat.mul(v9, Nat.add(x, 9n))), Nat.mul(v10, Nat.add(x, 10n))), Nat.mul(v11, Nat.add(x, 11n))), Nat.mul(v12, Nat.add(x, 12n))), Nat.mul(v13, Nat.add(x, 13n))), Nat.mul(v14, Nat.add(x, 14n))), Nat.mul(v15, Nat.add(x, 15n))), Nat.mul(v16, Nat.add(x, 16n))), Nat.mul(v17, Nat.add(x, 17n))), Nat.mul(v18, Nat.add(x, 18n))), Nat.mul(v19, Nat.add(x, 19n))), Nat.mul(v20, Nat.add(x, 20n))), Nat.mul(v21, Nat.add(x, 21n))), Nat.mul(v22, Nat.add(x, 22n))), Nat.mul(v23, Nat.add(x, 23n))), Nat.mul(v24, Nat.add(x, 24n))), Nat.mul(v25, Nat.add(x, 25n))), Nat.mul(v26, Nat.add(x, 26n))), Nat.mul(v27, Nat.add(x, 27n))), Nat.mul(v28, Nat.add(x, 28n))), Nat.mul(v29, Nat.add(x, 29n))), Nat.mul(v30, Nat.add(x, 30n))), Nat.mul(v31, Nat.add(x, 31n))), Nat.mul(v32, Nat.add(x, 32n))), Nat.mul(v33, Nat.add(x, 33n))), Nat.mul(v34, Nat.add(x, 34n))), Nat.mul(v35, Nat.add(x, 35n))), Nat.mul(v36, Nat.add(x, 36n))), Nat.mul(v37, Nat.add(x, 37n))), Nat.mul(v38, Nat.add(x, 38n))), Nat.mul(v39, Nat.add(x, 39n))), Nat.mul(v40, Nat.add(x, 40n))), Nat.mul(v41, Nat.add(x, 41n))), Nat.mul(v42, Nat.add(x, 42n))), Nat.mul(v43, Nat.add(x, 43n))), Nat.mul(v44, Nat.add(x, 44n))), Nat.mul(v45, Nat.add(x, 45n))), Nat.mul(v46, Nat.add(x, 46n))), Nat.mul(v47, Nat.add(x, 47n))), Nat.mul(v48, Nat.add(x, 48n))), Nat.mul(v49, Nat.add(x, 49n))), Nat.mul(v50, Nat.add(x, 50n))), Nat.mul(v51, Nat.add(x, 51n))), Nat.mul(v52, Nat.add(x, 52n))), Nat.mul(v53, Nat.add(x, 53n))), Nat.mul(v54, Nat.add(x, 54n))), Nat.mul(v55, Nat.add(x, 55n))), Nat.mul(v56, Nat.add(x, 56n))), Nat.mul(v57, Nat.add(x, 57n))), Nat.mul(v58, Nat.add(x, 58n))), Nat.mul(v59, Nat.add(x, 59n))), Nat.mul(v60, Nat.add(x, 60n))), Nat.mul(v61, Nat.add(x, 61n))), Nat.mul(v62, Nat.add(x, 62n))), Nat.mul(v63, Nat.add(x, 63n))), Nat.mul(v64, Nat.add(x, 64n))), Nat.mul(v65, Nat.add(x, 65n))), Nat.mul(v66, Nat.add(x, 66n))), Nat.mul(v67, Nat.add(x, 67n))), Nat.mul(v68, Nat.add(x, 68n))), Nat.mul(v69, Nat.add(x, 69n))), Nat.mul(v70, Nat.add(x, 70n))), Nat.mul(v71, Nat.add(x, 71n))), Nat.mul(v72, Nat.add(x, 72n))), Nat.mul(v73, Nat.add(x, 73n))), Nat.mul(v74, Nat.add(x, 74n))), Nat.mul(v75, Nat.add(x, 75n))), Nat.mul(v76, Nat.add(x, 76n))), Nat.mul(v77, Nat.add(x, 77n))), Nat.mul(v78, Nat.add(x, 78n))), Nat.mul(v79, Nat.add(x, 79n))), Nat.mul(v80, Nat.add(x, 80n))), Nat.mul(v81, Nat.add(x, 81n))), Nat.mul(v82, Nat.add(x, 82n))), Nat.mul(v83, Nat.add(x, 83n))), Nat.mul(v84, Nat.add(x, 84n))), Nat.mul(v85, Nat.add(x, 85n))), Nat.mul(v86, Nat.add(x, 86n))), Nat.mul(v87, Nat.add(x, 87n))), Nat.mul(v88, Nat.add(x, 88n))), Nat.mul(v89, Nat.add(x, 89n))), Nat.mul(v90, Nat.add(x, 90n))), Nat.mul(v91, Nat.add(x, 91n))), Nat.mul(v92, Nat.add(x, 92n))), Nat.mul(v93, Nat.add(x, 93n))), Nat.mul(v94, Nat.add(x, 94n))), Nat.mul(v95, Nat.add(x, 95n))), Nat.mul(v96, Nat.add(x, 96n))), Nat.mul(v97, Nat.add(x, 97n))), Nat.mul(v98, Nat.add(x, 98n))), Nat.mul(v99, Nat.add(x, 99n))), Nat.mul(v100, Nat.add(x, 100n))), Nat.mul(v101, Nat.add(x, 101n))), Nat.mul(v102, Nat.add(x, 102n))), Nat.mul(v103, Nat.add(x, 103n))), Nat.mul(v104, Nat.add(x, 104n))), Nat.mul(v105, Nat.add(x, 105n))), Nat.mul(v106, Nat.add(x, 106n))), Nat.mul(v107, Nat.add(x, 107n))), Nat.mul(v108, Nat.add(x, 108n))), Nat.mul(v109, Nat.add(x, 109n))), Nat.mul(v110, Nat.add(x, 110n))), Nat.mul(v111, Nat.add(x, 111n))), Nat.mul(v112, Nat.add(x, 112n))), Nat.mul(v113, Nat.add(x, 113n))), Nat.mul(v114, Nat.add(x, 114n))), Nat.mul(v115, Nat.add(x, 115n))), Nat.mul(v116, Nat.add(x, 116n))), Nat.mul(v117, Nat.add(x, 117n))), Nat.mul(v118, Nat.add(x, 118n))), Nat.mul(v119, Nat.add(x, 119n))), Nat.mul(v120, Nat.add(x, 120n))), Nat.mul(v121, Nat.add(x, 121n))), Nat.mul(v122, Nat.add(x, 122n))), Nat.mul(v123, Nat.add(x, 123n))), Nat.mul(v124, Nat.add(x, 124n))), Nat.mul(v125, Nat.add(x, 125n))), Nat.mul(v126, Nat.add(x, 126n))), Nat.mul(v127, Nat.add(x, 127n))), Nat.mul(v128, Nat.add(x, 128n))), Nat.mul(v129, Nat.add(x, 129n))), Nat.mul(v130, Nat.add(x, 130n))), Nat.mul(v131, Nat.add(x, 131n))), Nat.mul(v132, Nat.add(x, 132n))), Nat.mul(v133, Nat.add(x, 133n))), Nat.mul(v134, Nat.add(x, 134n))), Nat.mul(v135, Nat.add(x, 135n))), Nat.mul(v136, Nat.add(x, 136n))), Nat.mul(v137, Nat.add(x, 137n))), Nat.mul(v138, Nat.add(x, 138n))), Nat.mul(v139, Nat.add(x, 139n))), Nat.mul(v140, Nat.add(x, 140n))), Nat.mul(v141, Nat.add(x, 141n))), Nat.mul(v142, Nat.add(x, 142n))), Nat.mul(v143, Nat.add(x, 143n))), Nat.mul(v144, Nat.add(x, 144n))), Nat.mul(v145, Nat.add(x, 145n))), Nat.mul(v146, Nat.add(x, 146n))), Nat.mul(v147, Nat.add(x, 147n))), Nat.mul(v148, Nat.add(x, 148n))), Nat.mul(v149, Nat.add(x, 149n))), Nat.mul(v150, Nat.add(x, 150n))), Nat.mul(v151, Nat.add(x, 151n))), Nat.mul(v152, Nat.add(x, 152n))), Nat.mul(v153, Nat.add(x, 153n))), Nat.mul(v154, Nat.add(x, 154n))), Nat.mul(v155, Nat.add(x, 155n))), Nat.mul(v156, Nat.add(x, 156n))), Nat.mul(v157, Nat.add(x, 157n))), Nat.mul(v158, Nat.add(x, 158n))), Nat.mul(v159, Nat.add(x, 159n))), Nat.mul(v160, Nat.add(x, 160n))), Nat.mul(v161, Nat.add(x, 161n))), Nat.mul(v162, Nat.add(x, 162n))), Nat.mul(v163, Nat.add(x, 163n))), Nat.mul(v164, Nat.add(x, 164n))), Nat.mul(v165, Nat.add(x, 165n))), Nat.mul(v166, Nat.add(x, 166n))), Nat.mul(v167, Nat.add(x, 167n))), Nat.mul(v168, Nat.add(x, 168n))), Nat.mul(v169, Nat.add(x, 169n))), Nat.mul(v170, Nat.add(x, 170n))), Nat.mul(v171, Nat.add(x, 171n))), Nat.mul(v172, Nat.add(x, 172n))), Nat.mul(v173, Nat.add(x, 173n))), Nat.mul(v174, Nat.add(x, 174n))), Nat.mul(v175, Nat.add(x, 175n))), Nat.mul(v176, Nat.add(x, 176n))), Nat.mul(v177, Nat.add(x, 177n))), Nat.mul(v178, Nat.add(x, 178n))), Nat.mul(v179, Nat.add(x, 179n))), Nat.mul(v180, Nat.add(x, 180n))), Nat.mul(v181, Nat.add(x, 181n))), Nat.mul(v182, Nat.add(x, 182n))), Nat.mul(v183, Nat.add(x, 183n))), Nat.mul(v184, Nat.add(x, 184n))), Nat.mul(v185, Nat.add(x, 185n))), Nat.mul(v186, Nat.add(x, 186n))), Nat.mul(v187, Nat.add(x, 187n))), Nat.mul(v188, Nat.add(x, 188n))), Nat.mul(v189, Nat.add(x, 189n))), Nat.mul(v190, Nat.add(x, 190n))), Nat.mul(v191, Nat.add(x, 191n))), Nat.mul(v192, Nat.add(x, 192n))), Nat.mul(v193, Nat.add(x, 193n))), Nat.mul(v194, Nat.add(x, 194n))), Nat.mul(v195, Nat.add(x, 195n))), Nat.mul(v196, Nat.add(x, 196n))), Nat.mul(v197, Nat.add(x, 197n))), Nat.mul(v198, Nat.add(x, 198n))), Nat.mul(v199, Nat.add(x, 199n))), Nat.mul(v200, Nat.add(x, 200n))), Nat.mul(v201, Nat.add(x, 201n))), Nat.mul(v202, Nat.add(x, 202n))), Nat.mul(v203, Nat.add(x, 203n))), Nat.mul(v204, Nat.add(x, 204n))), Nat.mul(v205, Nat.add(x, 205n))), Nat.mul(v206, Nat.add(x, 206n))), Nat.mul(v207, Nat.add(x, 207n))), Nat.mul(v208, Nat.add(x, 208n))), Nat.mul(v209, Nat.add(x, 209n))), Nat.mul(v210, Nat.add(x, 210n))), Nat.mul(v211, Nat.add(x, 211n))), Nat.mul(v212, Nat.add(x, 212n))), Nat.mul(v213, Nat.add(x, 213n))), Nat.mul(v214, Nat.add(x, 214n))), Nat.mul(v215, Nat.add(x, 215n))), Nat.mul(v216, Nat.add(x, 216n))), Nat.mul(v217, Nat.add(x, 217n))), Nat.mul(v218, Nat.add(x, 218n))), Nat.mul(v219, Nat.add(x, 219n))), Nat.mul(v220, Nat.add(x, 220n))), Nat.mul(v221, Nat.add(x, 221n))), Nat.mul(v222, Nat.add(x, 222n))), Nat.mul(v223, Nat.add(x, 223n))), Nat.mul(v224, Nat.add(x, 224n))), Nat.mul(v225, Nat.add(x, 225n))), Nat.mul(v226, Nat.add(x, 226n))), Nat.mul(v227, Nat.add(x, 227n))), Nat.mul(v228, Nat.add(x, 228n))), Nat.mul(v229, Nat.add(x, 229n))), Nat.mul(v230, Nat.add(x, 230n))), Nat.mul(v231, Nat.add(x, 231n))), Nat.mul(v232, Nat.add(x, 232n))), Nat.mul(v233, Nat.add(x, 233n))), Nat.mul(v234, Nat.add(x, 234n))), Nat.mul(v235, Nat.add(x, 235n))), Nat.mul(v236, Nat.add(x, 236n))), Nat.mul(v237, Nat.add(x, 237n))), Nat.mul(v238, Nat.add(x, 238n))), Nat.mul(v239, Nat.add(x, 239n))), Nat.mul(v240, Nat.add(x, 240n))), Nat.mul(v241, Nat.add(x, 241n))), Nat.mul(v242, Nat.add(x, 242n))), Nat.mul(v243, Nat.add(x, 243n))), Nat.mul(v244, Nat.add(x, 244n))), Nat.mul(v245, Nat.add(x, 245n))), Nat.mul(v246, Nat.add(x, 246n))), Nat.mul(v247, Nat.add(x, 247n))), Nat.mul(v248, Nat.add(x, 248n))), Nat.mul(v249, Nat.add(x, 249n))), Nat.mul(v250, Nat.add(x, 250n))), Nat.mul(v251, Nat.add(x, 251n))), Nat.mul(v252, Nat.add(x, 252n))), Nat.mul(v253, Nat.add(x, 253n))), Nat.mul(v254, Nat.add(x, 254n))), Nat.mul(v255, Nat.add(x, 255n))), Nat.mul(v256, Nat.add(x, 256n))), Nat.mul(v257, Nat.add(x, 257n))), Nat.mul(v258, Nat.add(x, 258n))), Nat.mul(v259, Nat.add(x, 259n))), Nat.mul(v260, Nat.add(x, 260n))), Nat.mul(v261, Nat.add(x, 261n))), Nat.mul(v262, Nat.add(x, 262n))), Nat.mul(v263, Nat.add(x, 263n))), Nat.mul(v264, Nat.add(x, 264n))), Nat.mul(v265, Nat.add(x, 265n))), Nat.mul(v266, Nat.add(x, 266n))), Nat.mul(v267, Nat.add(x, 267n))), Nat.mul(v268, Nat.add(x, 268n))), Nat.mul(v269, Nat.add(x, 269n))), Nat.mul(v270, Nat.add(x, 270n))), Nat.mul(v271, Nat.add(x, 271n))), Nat.mul(v272, Nat.add(x, 272n))), Nat.mul(v273, Nat.add(x, 273n))), Nat.mul(v274, Nat.add(x, 274n))), Nat.mul(v275, Nat.add(x, 275n))), Nat.mul(v276, Nat.add(x, 276n))), Nat.mul(v277, Nat.add(x, 277n))), Nat.mul(v278, Nat.add(x, 278n))), Nat.mul(v279, Nat.add(x, 279n))), Nat.mul(v280, Nat.add(x, 280n))), Nat.mul(v281, Nat.add(x, 281n))), Nat.mul(v282, Nat.add(x, 282n))), Nat.mul(v283, Nat.add(x, 283n))), Nat.mul(v284, Nat.add(x, 284n))), Nat.mul(v285, Nat.add(x, 285n))), Nat.mul(v286, Nat.add(x, 286n))), Nat.mul(v287, Nat.add(x, 287n))), Nat.mul(v288, Nat.add(x, 288n))), Nat.mul(v289, Nat.add(x, 289n))), Nat.mul(v290, Nat.add(x, 290n))), Nat.mul(v291, Nat.add(x, 291n))), Nat.mul(v292, Nat.add(x, 292n))), Nat.mul(v293, Nat.add(x, 293n))), Nat.mul(v294, Nat.add(x, 294n))), Nat.mul(v295, Nat.add(x, 295n))), Nat.mul(v296, Nat.add(x, 296n))), Nat.mul(v297, Nat.add(x, 297n))), Nat.mul(v298, Nat.add(x, 298n))), Nat.mul(v299, Nat.add(x, 299n)))} + +def invoke(w: Wrapped, x: Nat) -> Nat: + match w: + case Wrap{f}: + f(x) + +def consume(+s: String) -> IO(Unit): + result = invoke(close(s), 7n) + expected = Nat.add(Nat.mul(String.length(s), 46950n), 135085n) + IO.print(Bool.show(Cmp.is_eq(Nat.cmp(result, expected)))) + +def main() -> IO(Unit): + do IO: + t: Nat <- IO.now() + consume(Nat.show(t)) + +#|True diff --git a/tests/reg/wide_live_continuation.bend b/tests/reg/wide_live_continuation.bend new file mode 100644 index 000000000..2bae82b63 --- /dev/null +++ b/tests/reg/wide_live_continuation.bend @@ -0,0 +1,24 @@ +# 248 live boxed fields survive continuation calls. +import Base + +type Wide is Data: + Mk{f0: String, f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String, f16: String, f17: String, f18: String, f19: String, f20: String, f21: String, f22: String, f23: String, f24: String, f25: String, f26: String, f27: String, f28: String, f29: String, f30: String, f31: String, f32: String, f33: String, f34: String, f35: String, f36: String, f37: String, f38: String, f39: String, f40: String, f41: String, f42: String, f43: String, f44: String, f45: String, f46: String, f47: String, f48: String, f49: String, f50: String, f51: String, f52: String, f53: String, f54: String, f55: String, f56: String, f57: String, f58: String, f59: String, f60: String, f61: String, f62: String, f63: String, f64: String, f65: String, f66: String, f67: String, f68: String, f69: String, f70: String, f71: String, f72: String, f73: String, f74: String, f75: String, f76: String, f77: String, f78: String, f79: String, f80: String, f81: String, f82: String, f83: String, f84: String, f85: String, f86: String, f87: String, f88: String, f89: String, f90: String, f91: String, f92: String, f93: String, f94: String, f95: String, f96: String, f97: String, f98: String, f99: String, f100: String, f101: String, f102: String, f103: String, f104: String, f105: String, f106: String, f107: String, f108: String, f109: String, f110: String, f111: String, f112: String, f113: String, f114: String, f115: String, f116: String, f117: String, f118: String, f119: String, f120: String, f121: String, f122: String, f123: String, f124: String, f125: String, f126: String, f127: String, f128: String, f129: String, f130: String, f131: String, f132: String, f133: String, f134: String, f135: String, f136: String, f137: String, f138: String, f139: String, f140: String, f141: String, f142: String, f143: String, f144: String, f145: String, f146: String, f147: String, f148: String, f149: String, f150: String, f151: String, f152: String, f153: String, f154: String, f155: String, f156: String, f157: String, f158: String, f159: String, f160: String, f161: String, f162: String, f163: String, f164: String, f165: String, f166: String, f167: String, f168: String, f169: String, f170: String, f171: String, f172: String, f173: String, f174: String, f175: String, f176: String, f177: String, f178: String, f179: String, f180: String, f181: String, f182: String, f183: String, f184: String, f185: String, f186: String, f187: String, f188: String, f189: String, f190: String, f191: String, f192: String, f193: String, f194: String, f195: String, f196: String, f197: String, f198: String, f199: String, f200: String, f201: String, f202: String, f203: String, f204: String, f205: String, f206: String, f207: String, f208: String, f209: String, f210: String, f211: String, f212: String, f213: String, f214: String, f215: String, f216: String, f217: String, f218: String, f219: String, f220: String, f221: String, f222: String, f223: String, f224: String, f225: String, f226: String, f227: String, f228: String, f229: String, f230: String, f231: String, f232: String, f233: String, f234: String, f235: String, f236: String, f237: String, f238: String, f239: String, f240: String, f241: String, f242: String, f243: String, f244: String, f245: String, f246: String, f247: String} + +def make(+s: String) -> Wide: + Mk{s ++ "0", s ++ "1", s ++ "2", s ++ "3", s ++ "4", s ++ "5", s ++ "6", s ++ "7", s ++ "8", s ++ "9", s ++ "10", s ++ "11", s ++ "12", s ++ "13", s ++ "14", s ++ "15", s ++ "16", s ++ "17", s ++ "18", s ++ "19", s ++ "20", s ++ "21", s ++ "22", s ++ "23", s ++ "24", s ++ "25", s ++ "26", s ++ "27", s ++ "28", s ++ "29", s ++ "30", s ++ "31", s ++ "32", s ++ "33", s ++ "34", s ++ "35", s ++ "36", s ++ "37", s ++ "38", s ++ "39", s ++ "40", s ++ "41", s ++ "42", s ++ "43", s ++ "44", s ++ "45", s ++ "46", s ++ "47", s ++ "48", s ++ "49", s ++ "50", s ++ "51", s ++ "52", s ++ "53", s ++ "54", s ++ "55", s ++ "56", s ++ "57", s ++ "58", s ++ "59", s ++ "60", s ++ "61", s ++ "62", s ++ "63", s ++ "64", s ++ "65", s ++ "66", s ++ "67", s ++ "68", s ++ "69", s ++ "70", s ++ "71", s ++ "72", s ++ "73", s ++ "74", s ++ "75", s ++ "76", s ++ "77", s ++ "78", s ++ "79", s ++ "80", s ++ "81", s ++ "82", s ++ "83", s ++ "84", s ++ "85", s ++ "86", s ++ "87", s ++ "88", s ++ "89", s ++ "90", s ++ "91", s ++ "92", s ++ "93", s ++ "94", s ++ "95", s ++ "96", s ++ "97", s ++ "98", s ++ "99", s ++ "100", s ++ "101", s ++ "102", s ++ "103", s ++ "104", s ++ "105", s ++ "106", s ++ "107", s ++ "108", s ++ "109", s ++ "110", s ++ "111", s ++ "112", s ++ "113", s ++ "114", s ++ "115", s ++ "116", s ++ "117", s ++ "118", s ++ "119", s ++ "120", s ++ "121", s ++ "122", s ++ "123", s ++ "124", s ++ "125", s ++ "126", s ++ "127", s ++ "128", s ++ "129", s ++ "130", s ++ "131", s ++ "132", s ++ "133", s ++ "134", s ++ "135", s ++ "136", s ++ "137", s ++ "138", s ++ "139", s ++ "140", s ++ "141", s ++ "142", s ++ "143", s ++ "144", s ++ "145", s ++ "146", s ++ "147", s ++ "148", s ++ "149", s ++ "150", s ++ "151", s ++ "152", s ++ "153", s ++ "154", s ++ "155", s ++ "156", s ++ "157", s ++ "158", s ++ "159", s ++ "160", s ++ "161", s ++ "162", s ++ "163", s ++ "164", s ++ "165", s ++ "166", s ++ "167", s ++ "168", s ++ "169", s ++ "170", s ++ "171", s ++ "172", s ++ "173", s ++ "174", s ++ "175", s ++ "176", s ++ "177", s ++ "178", s ++ "179", s ++ "180", s ++ "181", s ++ "182", s ++ "183", s ++ "184", s ++ "185", s ++ "186", s ++ "187", s ++ "188", s ++ "189", s ++ "190", s ++ "191", s ++ "192", s ++ "193", s ++ "194", s ++ "195", s ++ "196", s ++ "197", s ++ "198", s ++ "199", s ++ "200", s ++ "201", s ++ "202", s ++ "203", s ++ "204", s ++ "205", s ++ "206", s ++ "207", s ++ "208", s ++ "209", s ++ "210", s ++ "211", s ++ "212", s ++ "213", s ++ "214", s ++ "215", s ++ "216", s ++ "217", s ++ "218", s ++ "219", s ++ "220", s ++ "221", s ++ "222", s ++ "223", s ++ "224", s ++ "225", s ++ "226", s ++ "227", s ++ "228", s ++ "229", s ++ "230", s ++ "231", s ++ "232", s ++ "233", s ++ "234", s ++ "235", s ++ "236", s ++ "237", s ++ "238", s ++ "239", s ++ "240", s ++ "241", s ++ "242", s ++ "243", s ++ "244", s ++ "245", s ++ "246", s ++ "247"} + +def digest(r: Wide) -> Nat: + match r: + case Mk{f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, f42, f43, f44, f45, f46, f47, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65, f66, f67, f68, f69, f70, f71, f72, f73, f74, f75, f76, f77, f78, f79, f80, f81, f82, f83, f84, f85, f86, f87, f88, f89, f90, f91, f92, f93, f94, f95, f96, f97, f98, f99, f100, f101, f102, f103, f104, f105, f106, f107, f108, f109, f110, f111, f112, f113, f114, f115, f116, f117, f118, f119, f120, f121, f122, f123, f124, f125, f126, f127, f128, f129, f130, f131, f132, f133, f134, f135, f136, f137, f138, f139, f140, f141, f142, f143, f144, f145, f146, f147, f148, f149, f150, f151, f152, f153, f154, f155, f156, f157, f158, f159, f160, f161, f162, f163, f164, f165, f166, f167, f168, f169, f170, f171, f172, f173, f174, f175, f176, f177, f178, f179, f180, f181, f182, f183, f184, f185, f186, f187, f188, f189, f190, f191, f192, f193, f194, f195, f196, f197, f198, f199, f200, f201, f202, f203, f204, f205, f206, f207, f208, f209, f210, f211, f212, f213, f214, f215, f216, f217, f218, f219, f220, f221, f222, f223, f224, f225, f226, f227, f228, f229, f230, f231, f232, f233, f234, f235, f236, f237, f238, f239, f240, f241, f242, f243, f244, f245, f246, f247}: + Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(String.length(f0), String.length(f1)), String.length(f2)), String.length(f3)), String.length(f4)), String.length(f5)), String.length(f6)), String.length(f7)), String.length(f8)), String.length(f9)), String.length(f10)), String.length(f11)), String.length(f12)), String.length(f13)), String.length(f14)), String.length(f15)), String.length(f16)), String.length(f17)), String.length(f18)), String.length(f19)), String.length(f20)), String.length(f21)), String.length(f22)), String.length(f23)), String.length(f24)), String.length(f25)), String.length(f26)), String.length(f27)), String.length(f28)), String.length(f29)), String.length(f30)), String.length(f31)), String.length(f32)), String.length(f33)), String.length(f34)), String.length(f35)), String.length(f36)), String.length(f37)), String.length(f38)), String.length(f39)), String.length(f40)), String.length(f41)), String.length(f42)), String.length(f43)), String.length(f44)), String.length(f45)), String.length(f46)), String.length(f47)), String.length(f48)), String.length(f49)), String.length(f50)), String.length(f51)), String.length(f52)), String.length(f53)), String.length(f54)), String.length(f55)), String.length(f56)), String.length(f57)), String.length(f58)), String.length(f59)), String.length(f60)), String.length(f61)), String.length(f62)), String.length(f63)), String.length(f64)), String.length(f65)), String.length(f66)), String.length(f67)), String.length(f68)), String.length(f69)), String.length(f70)), String.length(f71)), String.length(f72)), String.length(f73)), String.length(f74)), String.length(f75)), String.length(f76)), String.length(f77)), String.length(f78)), String.length(f79)), String.length(f80)), String.length(f81)), String.length(f82)), String.length(f83)), String.length(f84)), String.length(f85)), String.length(f86)), String.length(f87)), String.length(f88)), String.length(f89)), String.length(f90)), String.length(f91)), String.length(f92)), String.length(f93)), String.length(f94)), String.length(f95)), String.length(f96)), String.length(f97)), String.length(f98)), String.length(f99)), String.length(f100)), String.length(f101)), String.length(f102)), String.length(f103)), String.length(f104)), String.length(f105)), String.length(f106)), String.length(f107)), String.length(f108)), String.length(f109)), String.length(f110)), String.length(f111)), String.length(f112)), String.length(f113)), String.length(f114)), String.length(f115)), String.length(f116)), String.length(f117)), String.length(f118)), String.length(f119)), String.length(f120)), String.length(f121)), String.length(f122)), String.length(f123)), String.length(f124)), String.length(f125)), String.length(f126)), String.length(f127)), String.length(f128)), String.length(f129)), String.length(f130)), String.length(f131)), String.length(f132)), String.length(f133)), String.length(f134)), String.length(f135)), String.length(f136)), String.length(f137)), String.length(f138)), String.length(f139)), String.length(f140)), String.length(f141)), String.length(f142)), String.length(f143)), String.length(f144)), String.length(f145)), String.length(f146)), String.length(f147)), String.length(f148)), String.length(f149)), String.length(f150)), String.length(f151)), String.length(f152)), String.length(f153)), String.length(f154)), String.length(f155)), String.length(f156)), String.length(f157)), String.length(f158)), String.length(f159)), String.length(f160)), String.length(f161)), String.length(f162)), String.length(f163)), String.length(f164)), String.length(f165)), String.length(f166)), String.length(f167)), String.length(f168)), String.length(f169)), String.length(f170)), String.length(f171)), String.length(f172)), String.length(f173)), String.length(f174)), String.length(f175)), String.length(f176)), String.length(f177)), String.length(f178)), String.length(f179)), String.length(f180)), String.length(f181)), String.length(f182)), String.length(f183)), String.length(f184)), String.length(f185)), String.length(f186)), String.length(f187)), String.length(f188)), String.length(f189)), String.length(f190)), String.length(f191)), String.length(f192)), String.length(f193)), String.length(f194)), String.length(f195)), String.length(f196)), String.length(f197)), String.length(f198)), String.length(f199)), String.length(f200)), String.length(f201)), String.length(f202)), String.length(f203)), String.length(f204)), String.length(f205)), String.length(f206)), String.length(f207)), String.length(f208)), String.length(f209)), String.length(f210)), String.length(f211)), String.length(f212)), String.length(f213)), String.length(f214)), String.length(f215)), String.length(f216)), String.length(f217)), String.length(f218)), String.length(f219)), String.length(f220)), String.length(f221)), String.length(f222)), String.length(f223)), String.length(f224)), String.length(f225)), String.length(f226)), String.length(f227)), String.length(f228)), String.length(f229)), String.length(f230)), String.length(f231)), String.length(f232)), String.length(f233)), String.length(f234)), String.length(f235)), String.length(f236)), String.length(f237)), String.length(f238)), String.length(f239)), String.length(f240)), String.length(f241)), String.length(f242)), String.length(f243)), String.length(f244)), String.length(f245)), String.length(f246)), String.length(f247)) + +def consume(+s: String) -> IO(Unit): + IO.print(Nat.show(Nat.sub(digest(make(s)), + Nat.mul(248n, String.length(s))))) + +def main() -> IO(Unit): + do IO: + t: Nat <- IO.now() + consume(Nat.show(t)) + +#|634 diff --git a/tests/reg/wide_live_fork.bend b/tests/reg/wide_live_fork.bend new file mode 100644 index 000000000..d494297e3 --- /dev/null +++ b/tests/reg/wide_live_fork.bend @@ -0,0 +1,323 @@ +# 300 live values survive a real pair of recursive fork operands. +import Base + +def triangle(+n: Nat) -> Nat: + match n: + case 0n: + 0n + case 1n+p: + Nat.add(n, triangle(p)) + +def consume(+s: String) -> IO(Unit): + v0 = String.length(s ++ "0") + v1 = String.length(s ++ "1") + v2 = String.length(s ++ "2") + v3 = String.length(s ++ "3") + v4 = String.length(s ++ "4") + v5 = String.length(s ++ "5") + v6 = String.length(s ++ "6") + v7 = String.length(s ++ "7") + v8 = String.length(s ++ "8") + v9 = String.length(s ++ "9") + v10 = String.length(s ++ "10") + v11 = String.length(s ++ "11") + v12 = String.length(s ++ "12") + v13 = String.length(s ++ "13") + v14 = String.length(s ++ "14") + v15 = String.length(s ++ "15") + v16 = String.length(s ++ "16") + v17 = String.length(s ++ "17") + v18 = String.length(s ++ "18") + v19 = String.length(s ++ "19") + v20 = String.length(s ++ "20") + v21 = String.length(s ++ "21") + v22 = String.length(s ++ "22") + v23 = String.length(s ++ "23") + v24 = String.length(s ++ "24") + v25 = String.length(s ++ "25") + v26 = String.length(s ++ "26") + v27 = String.length(s ++ "27") + v28 = String.length(s ++ "28") + v29 = String.length(s ++ "29") + v30 = String.length(s ++ "30") + v31 = String.length(s ++ "31") + v32 = String.length(s ++ "32") + v33 = String.length(s ++ "33") + v34 = String.length(s ++ "34") + v35 = String.length(s ++ "35") + v36 = String.length(s ++ "36") + v37 = String.length(s ++ "37") + v38 = String.length(s ++ "38") + v39 = String.length(s ++ "39") + v40 = String.length(s ++ "40") + v41 = String.length(s ++ "41") + v42 = String.length(s ++ "42") + v43 = String.length(s ++ "43") + v44 = String.length(s ++ "44") + v45 = String.length(s ++ "45") + v46 = String.length(s ++ "46") + v47 = String.length(s ++ "47") + v48 = String.length(s ++ "48") + v49 = String.length(s ++ "49") + v50 = String.length(s ++ "50") + v51 = String.length(s ++ "51") + v52 = String.length(s ++ "52") + v53 = String.length(s ++ "53") + v54 = String.length(s ++ "54") + v55 = String.length(s ++ "55") + v56 = String.length(s ++ "56") + v57 = String.length(s ++ "57") + v58 = String.length(s ++ "58") + v59 = String.length(s ++ "59") + v60 = String.length(s ++ "60") + v61 = String.length(s ++ "61") + v62 = String.length(s ++ "62") + v63 = String.length(s ++ "63") + v64 = String.length(s ++ "64") + v65 = String.length(s ++ "65") + v66 = String.length(s ++ "66") + v67 = String.length(s ++ "67") + v68 = String.length(s ++ "68") + v69 = String.length(s ++ "69") + v70 = String.length(s ++ "70") + v71 = String.length(s ++ "71") + v72 = String.length(s ++ "72") + v73 = String.length(s ++ "73") + v74 = String.length(s ++ "74") + v75 = String.length(s ++ "75") + v76 = String.length(s ++ "76") + v77 = String.length(s ++ "77") + v78 = String.length(s ++ "78") + v79 = String.length(s ++ "79") + v80 = String.length(s ++ "80") + v81 = String.length(s ++ "81") + v82 = String.length(s ++ "82") + v83 = String.length(s ++ "83") + v84 = String.length(s ++ "84") + v85 = String.length(s ++ "85") + v86 = String.length(s ++ "86") + v87 = String.length(s ++ "87") + v88 = String.length(s ++ "88") + v89 = String.length(s ++ "89") + v90 = String.length(s ++ "90") + v91 = String.length(s ++ "91") + v92 = String.length(s ++ "92") + v93 = String.length(s ++ "93") + v94 = String.length(s ++ "94") + v95 = String.length(s ++ "95") + v96 = String.length(s ++ "96") + v97 = String.length(s ++ "97") + v98 = String.length(s ++ "98") + v99 = String.length(s ++ "99") + v100 = String.length(s ++ "100") + v101 = String.length(s ++ "101") + v102 = String.length(s ++ "102") + v103 = String.length(s ++ "103") + v104 = String.length(s ++ "104") + v105 = String.length(s ++ "105") + v106 = String.length(s ++ "106") + v107 = String.length(s ++ "107") + v108 = String.length(s ++ "108") + v109 = String.length(s ++ "109") + v110 = String.length(s ++ "110") + v111 = String.length(s ++ "111") + v112 = String.length(s ++ "112") + v113 = String.length(s ++ "113") + v114 = String.length(s ++ "114") + v115 = String.length(s ++ "115") + v116 = String.length(s ++ "116") + v117 = String.length(s ++ "117") + v118 = String.length(s ++ "118") + v119 = String.length(s ++ "119") + v120 = String.length(s ++ "120") + v121 = String.length(s ++ "121") + v122 = String.length(s ++ "122") + v123 = String.length(s ++ "123") + v124 = String.length(s ++ "124") + v125 = String.length(s ++ "125") + v126 = String.length(s ++ "126") + v127 = String.length(s ++ "127") + v128 = String.length(s ++ "128") + v129 = String.length(s ++ "129") + v130 = String.length(s ++ "130") + v131 = String.length(s ++ "131") + v132 = String.length(s ++ "132") + v133 = String.length(s ++ "133") + v134 = String.length(s ++ "134") + v135 = String.length(s ++ "135") + v136 = String.length(s ++ "136") + v137 = String.length(s ++ "137") + v138 = String.length(s ++ "138") + v139 = String.length(s ++ "139") + v140 = String.length(s ++ "140") + v141 = String.length(s ++ "141") + v142 = String.length(s ++ "142") + v143 = String.length(s ++ "143") + v144 = String.length(s ++ "144") + v145 = String.length(s ++ "145") + v146 = String.length(s ++ "146") + v147 = String.length(s ++ "147") + v148 = String.length(s ++ "148") + v149 = String.length(s ++ "149") + v150 = String.length(s ++ "150") + v151 = String.length(s ++ "151") + v152 = String.length(s ++ "152") + v153 = String.length(s ++ "153") + v154 = String.length(s ++ "154") + v155 = String.length(s ++ "155") + v156 = String.length(s ++ "156") + v157 = String.length(s ++ "157") + v158 = String.length(s ++ "158") + v159 = String.length(s ++ "159") + v160 = String.length(s ++ "160") + v161 = String.length(s ++ "161") + v162 = String.length(s ++ "162") + v163 = String.length(s ++ "163") + v164 = String.length(s ++ "164") + v165 = String.length(s ++ "165") + v166 = String.length(s ++ "166") + v167 = String.length(s ++ "167") + v168 = String.length(s ++ "168") + v169 = String.length(s ++ "169") + v170 = String.length(s ++ "170") + v171 = String.length(s ++ "171") + v172 = String.length(s ++ "172") + v173 = String.length(s ++ "173") + v174 = String.length(s ++ "174") + v175 = String.length(s ++ "175") + v176 = String.length(s ++ "176") + v177 = String.length(s ++ "177") + v178 = String.length(s ++ "178") + v179 = String.length(s ++ "179") + v180 = String.length(s ++ "180") + v181 = String.length(s ++ "181") + v182 = String.length(s ++ "182") + v183 = String.length(s ++ "183") + v184 = String.length(s ++ "184") + v185 = String.length(s ++ "185") + v186 = String.length(s ++ "186") + v187 = String.length(s ++ "187") + v188 = String.length(s ++ "188") + v189 = String.length(s ++ "189") + v190 = String.length(s ++ "190") + v191 = String.length(s ++ "191") + v192 = String.length(s ++ "192") + v193 = String.length(s ++ "193") + v194 = String.length(s ++ "194") + v195 = String.length(s ++ "195") + v196 = String.length(s ++ "196") + v197 = String.length(s ++ "197") + v198 = String.length(s ++ "198") + v199 = String.length(s ++ "199") + v200 = String.length(s ++ "200") + v201 = String.length(s ++ "201") + v202 = String.length(s ++ "202") + v203 = String.length(s ++ "203") + v204 = String.length(s ++ "204") + v205 = String.length(s ++ "205") + v206 = String.length(s ++ "206") + v207 = String.length(s ++ "207") + v208 = String.length(s ++ "208") + v209 = String.length(s ++ "209") + v210 = String.length(s ++ "210") + v211 = String.length(s ++ "211") + v212 = String.length(s ++ "212") + v213 = String.length(s ++ "213") + v214 = String.length(s ++ "214") + v215 = String.length(s ++ "215") + v216 = String.length(s ++ "216") + v217 = String.length(s ++ "217") + v218 = String.length(s ++ "218") + v219 = String.length(s ++ "219") + v220 = String.length(s ++ "220") + v221 = String.length(s ++ "221") + v222 = String.length(s ++ "222") + v223 = String.length(s ++ "223") + v224 = String.length(s ++ "224") + v225 = String.length(s ++ "225") + v226 = String.length(s ++ "226") + v227 = String.length(s ++ "227") + v228 = String.length(s ++ "228") + v229 = String.length(s ++ "229") + v230 = String.length(s ++ "230") + v231 = String.length(s ++ "231") + v232 = String.length(s ++ "232") + v233 = String.length(s ++ "233") + v234 = String.length(s ++ "234") + v235 = String.length(s ++ "235") + v236 = String.length(s ++ "236") + v237 = String.length(s ++ "237") + v238 = String.length(s ++ "238") + v239 = String.length(s ++ "239") + v240 = String.length(s ++ "240") + v241 = String.length(s ++ "241") + v242 = String.length(s ++ "242") + v243 = String.length(s ++ "243") + v244 = String.length(s ++ "244") + v245 = String.length(s ++ "245") + v246 = String.length(s ++ "246") + v247 = String.length(s ++ "247") + v248 = String.length(s ++ "248") + v249 = String.length(s ++ "249") + v250 = String.length(s ++ "250") + v251 = String.length(s ++ "251") + v252 = String.length(s ++ "252") + v253 = String.length(s ++ "253") + v254 = String.length(s ++ "254") + v255 = String.length(s ++ "255") + v256 = String.length(s ++ "256") + v257 = String.length(s ++ "257") + v258 = String.length(s ++ "258") + v259 = String.length(s ++ "259") + v260 = String.length(s ++ "260") + v261 = String.length(s ++ "261") + v262 = String.length(s ++ "262") + v263 = String.length(s ++ "263") + v264 = String.length(s ++ "264") + v265 = String.length(s ++ "265") + v266 = String.length(s ++ "266") + v267 = String.length(s ++ "267") + v268 = String.length(s ++ "268") + v269 = String.length(s ++ "269") + v270 = String.length(s ++ "270") + v271 = String.length(s ++ "271") + v272 = String.length(s ++ "272") + v273 = String.length(s ++ "273") + v274 = String.length(s ++ "274") + v275 = String.length(s ++ "275") + v276 = String.length(s ++ "276") + v277 = String.length(s ++ "277") + v278 = String.length(s ++ "278") + v279 = String.length(s ++ "279") + v280 = String.length(s ++ "280") + v281 = String.length(s ++ "281") + v282 = String.length(s ++ "282") + v283 = String.length(s ++ "283") + v284 = String.length(s ++ "284") + v285 = String.length(s ++ "285") + v286 = String.length(s ++ "286") + v287 = String.length(s ++ "287") + v288 = String.length(s ++ "288") + v289 = String.length(s ++ "289") + v290 = String.length(s ++ "290") + v291 = String.length(s ++ "291") + v292 = String.length(s ++ "292") + v293 = String.length(s ++ "293") + v294 = String.length(s ++ "294") + v295 = String.length(s ++ "295") + v296 = String.length(s ++ "296") + v297 = String.length(s ++ "297") + v298 = String.length(s ++ "298") + v299 = String.length(s ++ "299") + a b = triangle(String.length(s)) triangle(Nat.add(String.length(s), 1n)) + total = Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(Nat.add(v0, v1), v2), v3), v4), v5), v6), v7), v8), v9), v10), v11), v12), v13), v14), v15), v16), v17), v18), v19), v20), v21), v22), v23), v24), v25), v26), v27), v28), v29), v30), v31), v32), v33), v34), v35), v36), v37), v38), v39), v40), v41), v42), v43), v44), v45), v46), v47), v48), v49), v50), v51), v52), v53), v54), v55), v56), v57), v58), v59), v60), v61), v62), v63), v64), v65), v66), v67), v68), v69), v70), v71), v72), v73), v74), v75), v76), v77), v78), v79), v80), v81), v82), v83), v84), v85), v86), v87), v88), v89), v90), v91), v92), v93), v94), v95), v96), v97), v98), v99), v100), v101), v102), v103), v104), v105), v106), v107), v108), v109), v110), v111), v112), v113), v114), v115), v116), v117), v118), v119), v120), v121), v122), v123), v124), v125), v126), v127), v128), v129), v130), v131), v132), v133), v134), v135), v136), v137), v138), v139), v140), v141), v142), v143), v144), v145), v146), v147), v148), v149), v150), v151), v152), v153), v154), v155), v156), v157), v158), v159), v160), v161), v162), v163), v164), v165), v166), v167), v168), v169), v170), v171), v172), v173), v174), v175), v176), v177), v178), v179), v180), v181), v182), v183), v184), v185), v186), v187), v188), v189), v190), v191), v192), v193), v194), v195), v196), v197), v198), v199), v200), v201), v202), v203), v204), v205), v206), v207), v208), v209), v210), v211), v212), v213), v214), v215), v216), v217), v218), v219), v220), v221), v222), v223), v224), v225), v226), v227), v228), v229), v230), v231), v232), v233), v234), v235), v236), v237), v238), v239), v240), v241), v242), v243), v244), v245), v246), v247), v248), v249), v250), v251), v252), v253), v254), v255), v256), v257), v258), v259), v260), v261), v262), v263), v264), v265), v266), v267), v268), v269), v270), v271), v272), v273), v274), v275), v276), v277), v278), v279), v280), v281), v282), v283), v284), v285), v286), v287), v288), v289), v290), v291), v292), v293), v294), v295), v296), v297), v298), v299), a), b) + +length = String.length(s) + baseline = Nat.add(Nat.mul(length, 300n), Nat.mul(Nat.add(length, 1n), Nat.add(length, 1n))) + IO.print(Nat.show(Nat.sub(total, baseline))) + +def main() -> IO(Unit): + do IO: + t: Nat <- IO.now() + consume(Nat.show(t)) + +#|790 diff --git a/tests/reg/wide_native_spin.bend b/tests/reg/wide_native_spin.bend new file mode 100644 index 000000000..8b73155f7 --- /dev/null +++ b/tests/reg/wide_native_spin.bend @@ -0,0 +1,325 @@ +# A 301-word ordinary C spin preserves weighted order during self jumps. +import Base + +# A wide native spin must keep its ordinary C parameters during a self jump. +def rotate(n: Nat, v0: Nat, v1: Nat, v2: Nat, v3: Nat, v4: Nat, v5: Nat, v6: Nat, v7: Nat, v8: Nat, v9: Nat, v10: Nat, v11: Nat, v12: Nat, v13: Nat, v14: Nat, v15: Nat, v16: Nat, v17: Nat, v18: Nat, v19: Nat, v20: Nat, v21: Nat, v22: Nat, v23: Nat, v24: Nat, v25: Nat, v26: Nat, v27: Nat, v28: Nat, v29: Nat, v30: Nat, v31: Nat, v32: Nat, v33: Nat, v34: Nat, v35: Nat, v36: Nat, v37: Nat, v38: Nat, v39: Nat, v40: Nat, v41: Nat, v42: Nat, v43: Nat, v44: Nat, v45: Nat, v46: Nat, v47: Nat, v48: Nat, v49: Nat, v50: Nat, v51: Nat, v52: Nat, v53: Nat, v54: Nat, v55: Nat, v56: Nat, v57: Nat, v58: Nat, v59: Nat, v60: Nat, v61: Nat, v62: Nat, v63: Nat, v64: Nat, v65: Nat, v66: Nat, v67: Nat, v68: Nat, v69: Nat, v70: Nat, v71: Nat, v72: Nat, v73: Nat, v74: Nat, v75: Nat, v76: Nat, v77: Nat, v78: Nat, v79: Nat, v80: Nat, v81: Nat, v82: Nat, v83: Nat, v84: Nat, v85: Nat, v86: Nat, v87: Nat, v88: Nat, v89: Nat, v90: Nat, v91: Nat, v92: Nat, v93: Nat, v94: Nat, v95: Nat, v96: Nat, v97: Nat, v98: Nat, v99: Nat, v100: Nat, v101: Nat, v102: Nat, v103: Nat, v104: Nat, v105: Nat, v106: Nat, v107: Nat, v108: Nat, v109: Nat, v110: Nat, v111: Nat, v112: Nat, v113: Nat, v114: Nat, v115: Nat, v116: Nat, v117: Nat, v118: Nat, v119: Nat, v120: Nat, v121: Nat, v122: Nat, v123: Nat, v124: Nat, v125: Nat, v126: Nat, v127: Nat, v128: Nat, v129: Nat, v130: Nat, v131: Nat, v132: Nat, v133: Nat, v134: Nat, v135: Nat, v136: Nat, v137: Nat, v138: Nat, v139: Nat, v140: Nat, v141: Nat, v142: Nat, v143: Nat, v144: Nat, v145: Nat, v146: Nat, v147: Nat, v148: Nat, v149: Nat, v150: Nat, v151: Nat, v152: Nat, v153: Nat, v154: Nat, v155: Nat, v156: Nat, v157: Nat, v158: Nat, v159: Nat, v160: Nat, v161: Nat, v162: Nat, v163: Nat, v164: Nat, v165: Nat, v166: Nat, v167: Nat, v168: Nat, v169: Nat, v170: Nat, v171: Nat, v172: Nat, v173: Nat, v174: Nat, v175: Nat, v176: Nat, v177: Nat, v178: Nat, v179: Nat, v180: Nat, v181: Nat, v182: Nat, v183: Nat, v184: Nat, v185: Nat, v186: Nat, v187: Nat, v188: Nat, v189: Nat, v190: Nat, v191: Nat, v192: Nat, v193: Nat, v194: Nat, v195: Nat, v196: Nat, v197: Nat, v198: Nat, v199: Nat, v200: Nat, v201: Nat, v202: Nat, v203: Nat, v204: Nat, v205: Nat, v206: Nat, v207: Nat, v208: Nat, v209: Nat, v210: Nat, v211: Nat, v212: Nat, v213: Nat, v214: Nat, v215: Nat, v216: Nat, v217: Nat, v218: Nat, v219: Nat, v220: Nat, v221: Nat, v222: Nat, v223: Nat, v224: Nat, v225: Nat, v226: Nat, v227: Nat, v228: Nat, v229: Nat, v230: Nat, v231: Nat, v232: Nat, v233: Nat, v234: Nat, v235: Nat, v236: Nat, v237: Nat, v238: Nat, v239: Nat, v240: Nat, v241: Nat, v242: Nat, v243: Nat, v244: Nat, v245: Nat, v246: Nat, v247: Nat, v248: Nat, v249: Nat, v250: Nat, v251: Nat, v252: Nat, v253: Nat, v254: Nat, v255: Nat, v256: Nat, v257: Nat, v258: Nat, v259: Nat, v260: Nat, v261: Nat, v262: Nat, v263: Nat, v264: Nat, v265: Nat, v266: Nat, v267: Nat, v268: Nat, v269: Nat, v270: Nat, v271: Nat, v272: Nat, v273: Nat, v274: Nat, v275: Nat, v276: Nat, v277: Nat, v278: Nat, v279: Nat, v280: Nat, v281: Nat, v282: Nat, v283: Nat, v284: Nat, v285: Nat, v286: Nat, v287: Nat, v288: Nat, v289: Nat, v290: Nat, v291: Nat, v292: Nat, v293: Nat, v294: Nat, v295: Nat, v296: Nat, v297: Nat, v298: Nat, v299: Nat) -> Nat: + match n: + case 0n: + Nat.add(Nat.mul(v0, 1n), Nat.add(Nat.mul(v1, 2n), Nat.add(Nat.mul(v2, 3n), Nat.add(Nat.mul(v3, 4n), Nat.add(Nat.mul(v4, 5n), Nat.add(Nat.mul(v5, 6n), Nat.add(Nat.mul(v6, 7n), Nat.add(Nat.mul(v7, 8n), Nat.add(Nat.mul(v8, 9n), Nat.add(Nat.mul(v9, 10n), Nat.add(Nat.mul(v10, 11n), Nat.add(Nat.mul(v11, 12n), Nat.add(Nat.mul(v12, 13n), Nat.add(Nat.mul(v13, 14n), Nat.add(Nat.mul(v14, 15n), Nat.add(Nat.mul(v15, 16n), Nat.add(Nat.mul(v16, 17n), Nat.add(Nat.mul(v17, 18n), Nat.add(Nat.mul(v18, 19n), Nat.add(Nat.mul(v19, 20n), Nat.add(Nat.mul(v20, 21n), Nat.add(Nat.mul(v21, 22n), Nat.add(Nat.mul(v22, 23n), Nat.add(Nat.mul(v23, 24n), Nat.add(Nat.mul(v24, 25n), Nat.add(Nat.mul(v25, 26n), Nat.add(Nat.mul(v26, 27n), Nat.add(Nat.mul(v27, 28n), Nat.add(Nat.mul(v28, 29n), Nat.add(Nat.mul(v29, 30n), Nat.add(Nat.mul(v30, 31n), Nat.add(Nat.mul(v31, 32n), Nat.add(Nat.mul(v32, 33n), Nat.add(Nat.mul(v33, 34n), Nat.add(Nat.mul(v34, 35n), Nat.add(Nat.mul(v35, 36n), Nat.add(Nat.mul(v36, 37n), Nat.add(Nat.mul(v37, 38n), Nat.add(Nat.mul(v38, 39n), Nat.add(Nat.mul(v39, 40n), Nat.add(Nat.mul(v40, 41n), Nat.add(Nat.mul(v41, 42n), Nat.add(Nat.mul(v42, 43n), Nat.add(Nat.mul(v43, 44n), Nat.add(Nat.mul(v44, 45n), Nat.add(Nat.mul(v45, 46n), Nat.add(Nat.mul(v46, 47n), Nat.add(Nat.mul(v47, 48n), Nat.add(Nat.mul(v48, 49n), Nat.add(Nat.mul(v49, 50n), Nat.add(Nat.mul(v50, 51n), Nat.add(Nat.mul(v51, 52n), Nat.add(Nat.mul(v52, 53n), Nat.add(Nat.mul(v53, 54n), Nat.add(Nat.mul(v54, 55n), Nat.add(Nat.mul(v55, 56n), Nat.add(Nat.mul(v56, 57n), Nat.add(Nat.mul(v57, 58n), Nat.add(Nat.mul(v58, 59n), Nat.add(Nat.mul(v59, 60n), Nat.add(Nat.mul(v60, 61n), Nat.add(Nat.mul(v61, 62n), Nat.add(Nat.mul(v62, 63n), Nat.add(Nat.mul(v63, 64n), Nat.add(Nat.mul(v64, 65n), Nat.add(Nat.mul(v65, 66n), Nat.add(Nat.mul(v66, 67n), Nat.add(Nat.mul(v67, 68n), Nat.add(Nat.mul(v68, 69n), Nat.add(Nat.mul(v69, 70n), Nat.add(Nat.mul(v70, 71n), Nat.add(Nat.mul(v71, 72n), Nat.add(Nat.mul(v72, 73n), Nat.add(Nat.mul(v73, 74n), Nat.add(Nat.mul(v74, 75n), Nat.add(Nat.mul(v75, 76n), Nat.add(Nat.mul(v76, 77n), Nat.add(Nat.mul(v77, 78n), Nat.add(Nat.mul(v78, 79n), Nat.add(Nat.mul(v79, 80n), Nat.add(Nat.mul(v80, 81n), Nat.add(Nat.mul(v81, 82n), Nat.add(Nat.mul(v82, 83n), Nat.add(Nat.mul(v83, 84n), Nat.add(Nat.mul(v84, 85n), Nat.add(Nat.mul(v85, 86n), Nat.add(Nat.mul(v86, 87n), Nat.add(Nat.mul(v87, 88n), Nat.add(Nat.mul(v88, 89n), Nat.add(Nat.mul(v89, 90n), Nat.add(Nat.mul(v90, 91n), Nat.add(Nat.mul(v91, 92n), Nat.add(Nat.mul(v92, 93n), Nat.add(Nat.mul(v93, 94n), Nat.add(Nat.mul(v94, 95n), Nat.add(Nat.mul(v95, 96n), Nat.add(Nat.mul(v96, 97n), Nat.add(Nat.mul(v97, 98n), Nat.add(Nat.mul(v98, 99n), Nat.add(Nat.mul(v99, 100n), Nat.add(Nat.mul(v100, 101n), Nat.add(Nat.mul(v101, 102n), Nat.add(Nat.mul(v102, 103n), Nat.add(Nat.mul(v103, 104n), Nat.add(Nat.mul(v104, 105n), Nat.add(Nat.mul(v105, 106n), Nat.add(Nat.mul(v106, 107n), Nat.add(Nat.mul(v107, 108n), Nat.add(Nat.mul(v108, 109n), Nat.add(Nat.mul(v109, 110n), Nat.add(Nat.mul(v110, 111n), Nat.add(Nat.mul(v111, 112n), Nat.add(Nat.mul(v112, 113n), Nat.add(Nat.mul(v113, 114n), Nat.add(Nat.mul(v114, 115n), Nat.add(Nat.mul(v115, 116n), Nat.add(Nat.mul(v116, 117n), Nat.add(Nat.mul(v117, 118n), Nat.add(Nat.mul(v118, 119n), Nat.add(Nat.mul(v119, 120n), Nat.add(Nat.mul(v120, 121n), Nat.add(Nat.mul(v121, 122n), Nat.add(Nat.mul(v122, 123n), Nat.add(Nat.mul(v123, 124n), Nat.add(Nat.mul(v124, 125n), Nat.add(Nat.mul(v125, 126n), Nat.add(Nat.mul(v126, 127n), Nat.add(Nat.mul(v127, 128n), Nat.add(Nat.mul(v128, 129n), Nat.add(Nat.mul(v129, 130n), Nat.add(Nat.mul(v130, 131n), Nat.add(Nat.mul(v131, 132n), Nat.add(Nat.mul(v132, 133n), Nat.add(Nat.mul(v133, 134n), Nat.add(Nat.mul(v134, 135n), Nat.add(Nat.mul(v135, 136n), Nat.add(Nat.mul(v136, 137n), Nat.add(Nat.mul(v137, 138n), Nat.add(Nat.mul(v138, 139n), Nat.add(Nat.mul(v139, 140n), Nat.add(Nat.mul(v140, 141n), Nat.add(Nat.mul(v141, 142n), Nat.add(Nat.mul(v142, 143n), Nat.add(Nat.mul(v143, 144n), Nat.add(Nat.mul(v144, 145n), Nat.add(Nat.mul(v145, 146n), Nat.add(Nat.mul(v146, 147n), Nat.add(Nat.mul(v147, 148n), Nat.add(Nat.mul(v148, 149n), Nat.add(Nat.mul(v149, 150n), Nat.add(Nat.mul(v150, 151n), Nat.add(Nat.mul(v151, 152n), Nat.add(Nat.mul(v152, 153n), Nat.add(Nat.mul(v153, 154n), Nat.add(Nat.mul(v154, 155n), Nat.add(Nat.mul(v155, 156n), Nat.add(Nat.mul(v156, 157n), Nat.add(Nat.mul(v157, 158n), Nat.add(Nat.mul(v158, 159n), Nat.add(Nat.mul(v159, 160n), Nat.add(Nat.mul(v160, 161n), Nat.add(Nat.mul(v161, 162n), Nat.add(Nat.mul(v162, 163n), Nat.add(Nat.mul(v163, 164n), Nat.add(Nat.mul(v164, 165n), Nat.add(Nat.mul(v165, 166n), Nat.add(Nat.mul(v166, 167n), Nat.add(Nat.mul(v167, 168n), Nat.add(Nat.mul(v168, 169n), Nat.add(Nat.mul(v169, 170n), Nat.add(Nat.mul(v170, 171n), Nat.add(Nat.mul(v171, 172n), Nat.add(Nat.mul(v172, 173n), Nat.add(Nat.mul(v173, 174n), Nat.add(Nat.mul(v174, 175n), Nat.add(Nat.mul(v175, 176n), Nat.add(Nat.mul(v176, 177n), Nat.add(Nat.mul(v177, 178n), Nat.add(Nat.mul(v178, 179n), Nat.add(Nat.mul(v179, 180n), Nat.add(Nat.mul(v180, 181n), Nat.add(Nat.mul(v181, 182n), Nat.add(Nat.mul(v182, 183n), Nat.add(Nat.mul(v183, 184n), Nat.add(Nat.mul(v184, 185n), Nat.add(Nat.mul(v185, 186n), Nat.add(Nat.mul(v186, 187n), Nat.add(Nat.mul(v187, 188n), Nat.add(Nat.mul(v188, 189n), Nat.add(Nat.mul(v189, 190n), Nat.add(Nat.mul(v190, 191n), Nat.add(Nat.mul(v191, 192n), Nat.add(Nat.mul(v192, 193n), Nat.add(Nat.mul(v193, 194n), Nat.add(Nat.mul(v194, 195n), Nat.add(Nat.mul(v195, 196n), Nat.add(Nat.mul(v196, 197n), Nat.add(Nat.mul(v197, 198n), Nat.add(Nat.mul(v198, 199n), Nat.add(Nat.mul(v199, 200n), Nat.add(Nat.mul(v200, 201n), Nat.add(Nat.mul(v201, 202n), Nat.add(Nat.mul(v202, 203n), Nat.add(Nat.mul(v203, 204n), Nat.add(Nat.mul(v204, 205n), Nat.add(Nat.mul(v205, 206n), Nat.add(Nat.mul(v206, 207n), Nat.add(Nat.mul(v207, 208n), Nat.add(Nat.mul(v208, 209n), Nat.add(Nat.mul(v209, 210n), Nat.add(Nat.mul(v210, 211n), Nat.add(Nat.mul(v211, 212n), Nat.add(Nat.mul(v212, 213n), Nat.add(Nat.mul(v213, 214n), Nat.add(Nat.mul(v214, 215n), Nat.add(Nat.mul(v215, 216n), Nat.add(Nat.mul(v216, 217n), Nat.add(Nat.mul(v217, 218n), Nat.add(Nat.mul(v218, 219n), Nat.add(Nat.mul(v219, 220n), Nat.add(Nat.mul(v220, 221n), Nat.add(Nat.mul(v221, 222n), Nat.add(Nat.mul(v222, 223n), Nat.add(Nat.mul(v223, 224n), Nat.add(Nat.mul(v224, 225n), Nat.add(Nat.mul(v225, 226n), Nat.add(Nat.mul(v226, 227n), Nat.add(Nat.mul(v227, 228n), Nat.add(Nat.mul(v228, 229n), Nat.add(Nat.mul(v229, 230n), Nat.add(Nat.mul(v230, 231n), Nat.add(Nat.mul(v231, 232n), Nat.add(Nat.mul(v232, 233n), Nat.add(Nat.mul(v233, 234n), Nat.add(Nat.mul(v234, 235n), Nat.add(Nat.mul(v235, 236n), Nat.add(Nat.mul(v236, 237n), Nat.add(Nat.mul(v237, 238n), Nat.add(Nat.mul(v238, 239n), Nat.add(Nat.mul(v239, 240n), Nat.add(Nat.mul(v240, 241n), Nat.add(Nat.mul(v241, 242n), Nat.add(Nat.mul(v242, 243n), Nat.add(Nat.mul(v243, 244n), Nat.add(Nat.mul(v244, 245n), Nat.add(Nat.mul(v245, 246n), Nat.add(Nat.mul(v246, 247n), Nat.add(Nat.mul(v247, 248n), Nat.add(Nat.mul(v248, 249n), Nat.add(Nat.mul(v249, 250n), Nat.add(Nat.mul(v250, 251n), Nat.add(Nat.mul(v251, 252n), Nat.add(Nat.mul(v252, 253n), Nat.add(Nat.mul(v253, 254n), Nat.add(Nat.mul(v254, 255n), Nat.add(Nat.mul(v255, 256n), Nat.add(Nat.mul(v256, 257n), Nat.add(Nat.mul(v257, 258n), Nat.add(Nat.mul(v258, 259n), Nat.add(Nat.mul(v259, 260n), Nat.add(Nat.mul(v260, 261n), Nat.add(Nat.mul(v261, 262n), Nat.add(Nat.mul(v262, 263n), Nat.add(Nat.mul(v263, 264n), Nat.add(Nat.mul(v264, 265n), Nat.add(Nat.mul(v265, 266n), Nat.add(Nat.mul(v266, 267n), Nat.add(Nat.mul(v267, 268n), Nat.add(Nat.mul(v268, 269n), Nat.add(Nat.mul(v269, 270n), Nat.add(Nat.mul(v270, 271n), Nat.add(Nat.mul(v271, 272n), Nat.add(Nat.mul(v272, 273n), Nat.add(Nat.mul(v273, 274n), Nat.add(Nat.mul(v274, 275n), Nat.add(Nat.mul(v275, 276n), Nat.add(Nat.mul(v276, 277n), Nat.add(Nat.mul(v277, 278n), Nat.add(Nat.mul(v278, 279n), Nat.add(Nat.mul(v279, 280n), Nat.add(Nat.mul(v280, 281n), Nat.add(Nat.mul(v281, 282n), Nat.add(Nat.mul(v282, 283n), Nat.add(Nat.mul(v283, 284n), Nat.add(Nat.mul(v284, 285n), Nat.add(Nat.mul(v285, 286n), Nat.add(Nat.mul(v286, 287n), Nat.add(Nat.mul(v287, 288n), Nat.add(Nat.mul(v288, 289n), Nat.add(Nat.mul(v289, 290n), Nat.add(Nat.mul(v290, 291n), Nat.add(Nat.mul(v291, 292n), Nat.add(Nat.mul(v292, 293n), Nat.add(Nat.mul(v293, 294n), Nat.add(Nat.mul(v294, 295n), Nat.add(Nat.mul(v295, 296n), Nat.add(Nat.mul(v296, 297n), Nat.add(Nat.mul(v297, 298n), Nat.add(Nat.mul(v298, 299n), Nat.mul(v299, 300n)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + case 1n+p: + rotate(p, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v0) + +def consume(+t: Nat) -> IO(Unit): + +s = Nat.show(t) + +n = Nat.add(Nat.mod(t, 3n), 1n) + v0 = Nat.add(String.length(s), 0n) + v1 = Nat.add(String.length(s), 1n) + v2 = Nat.add(String.length(s), 2n) + v3 = Nat.add(String.length(s), 3n) + v4 = Nat.add(String.length(s), 4n) + v5 = Nat.add(String.length(s), 5n) + v6 = Nat.add(String.length(s), 6n) + v7 = Nat.add(String.length(s), 7n) + v8 = Nat.add(String.length(s), 8n) + v9 = Nat.add(String.length(s), 9n) + v10 = Nat.add(String.length(s), 10n) + v11 = Nat.add(String.length(s), 11n) + v12 = Nat.add(String.length(s), 12n) + v13 = Nat.add(String.length(s), 13n) + v14 = Nat.add(String.length(s), 14n) + v15 = Nat.add(String.length(s), 15n) + v16 = Nat.add(String.length(s), 16n) + v17 = Nat.add(String.length(s), 17n) + v18 = Nat.add(String.length(s), 18n) + v19 = Nat.add(String.length(s), 19n) + v20 = Nat.add(String.length(s), 20n) + v21 = Nat.add(String.length(s), 21n) + v22 = Nat.add(String.length(s), 22n) + v23 = Nat.add(String.length(s), 23n) + v24 = Nat.add(String.length(s), 24n) + v25 = Nat.add(String.length(s), 25n) + v26 = Nat.add(String.length(s), 26n) + v27 = Nat.add(String.length(s), 27n) + v28 = Nat.add(String.length(s), 28n) + v29 = Nat.add(String.length(s), 29n) + v30 = Nat.add(String.length(s), 30n) + v31 = Nat.add(String.length(s), 31n) + v32 = Nat.add(String.length(s), 32n) + v33 = Nat.add(String.length(s), 33n) + v34 = Nat.add(String.length(s), 34n) + v35 = Nat.add(String.length(s), 35n) + v36 = Nat.add(String.length(s), 36n) + v37 = Nat.add(String.length(s), 37n) + v38 = Nat.add(String.length(s), 38n) + v39 = Nat.add(String.length(s), 39n) + v40 = Nat.add(String.length(s), 40n) + v41 = Nat.add(String.length(s), 41n) + v42 = Nat.add(String.length(s), 42n) + v43 = Nat.add(String.length(s), 43n) + v44 = Nat.add(String.length(s), 44n) + v45 = Nat.add(String.length(s), 45n) + v46 = Nat.add(String.length(s), 46n) + v47 = Nat.add(String.length(s), 47n) + v48 = Nat.add(String.length(s), 48n) + v49 = Nat.add(String.length(s), 49n) + v50 = Nat.add(String.length(s), 50n) + v51 = Nat.add(String.length(s), 51n) + v52 = Nat.add(String.length(s), 52n) + v53 = Nat.add(String.length(s), 53n) + v54 = Nat.add(String.length(s), 54n) + v55 = Nat.add(String.length(s), 55n) + v56 = Nat.add(String.length(s), 56n) + v57 = Nat.add(String.length(s), 57n) + v58 = Nat.add(String.length(s), 58n) + v59 = Nat.add(String.length(s), 59n) + v60 = Nat.add(String.length(s), 60n) + v61 = Nat.add(String.length(s), 61n) + v62 = Nat.add(String.length(s), 62n) + v63 = Nat.add(String.length(s), 63n) + v64 = Nat.add(String.length(s), 64n) + v65 = Nat.add(String.length(s), 65n) + v66 = Nat.add(String.length(s), 66n) + v67 = Nat.add(String.length(s), 67n) + v68 = Nat.add(String.length(s), 68n) + v69 = Nat.add(String.length(s), 69n) + v70 = Nat.add(String.length(s), 70n) + v71 = Nat.add(String.length(s), 71n) + v72 = Nat.add(String.length(s), 72n) + v73 = Nat.add(String.length(s), 73n) + v74 = Nat.add(String.length(s), 74n) + v75 = Nat.add(String.length(s), 75n) + v76 = Nat.add(String.length(s), 76n) + v77 = Nat.add(String.length(s), 77n) + v78 = Nat.add(String.length(s), 78n) + v79 = Nat.add(String.length(s), 79n) + v80 = Nat.add(String.length(s), 80n) + v81 = Nat.add(String.length(s), 81n) + v82 = Nat.add(String.length(s), 82n) + v83 = Nat.add(String.length(s), 83n) + v84 = Nat.add(String.length(s), 84n) + v85 = Nat.add(String.length(s), 85n) + v86 = Nat.add(String.length(s), 86n) + v87 = Nat.add(String.length(s), 87n) + v88 = Nat.add(String.length(s), 88n) + v89 = Nat.add(String.length(s), 89n) + v90 = Nat.add(String.length(s), 90n) + v91 = Nat.add(String.length(s), 91n) + v92 = Nat.add(String.length(s), 92n) + v93 = Nat.add(String.length(s), 93n) + v94 = Nat.add(String.length(s), 94n) + v95 = Nat.add(String.length(s), 95n) + v96 = Nat.add(String.length(s), 96n) + v97 = Nat.add(String.length(s), 97n) + v98 = Nat.add(String.length(s), 98n) + v99 = Nat.add(String.length(s), 99n) + v100 = Nat.add(String.length(s), 100n) + v101 = Nat.add(String.length(s), 101n) + v102 = Nat.add(String.length(s), 102n) + v103 = Nat.add(String.length(s), 103n) + v104 = Nat.add(String.length(s), 104n) + v105 = Nat.add(String.length(s), 105n) + v106 = Nat.add(String.length(s), 106n) + v107 = Nat.add(String.length(s), 107n) + v108 = Nat.add(String.length(s), 108n) + v109 = Nat.add(String.length(s), 109n) + v110 = Nat.add(String.length(s), 110n) + v111 = Nat.add(String.length(s), 111n) + v112 = Nat.add(String.length(s), 112n) + v113 = Nat.add(String.length(s), 113n) + v114 = Nat.add(String.length(s), 114n) + v115 = Nat.add(String.length(s), 115n) + v116 = Nat.add(String.length(s), 116n) + v117 = Nat.add(String.length(s), 117n) + v118 = Nat.add(String.length(s), 118n) + v119 = Nat.add(String.length(s), 119n) + v120 = Nat.add(String.length(s), 120n) + v121 = Nat.add(String.length(s), 121n) + v122 = Nat.add(String.length(s), 122n) + v123 = Nat.add(String.length(s), 123n) + v124 = Nat.add(String.length(s), 124n) + v125 = Nat.add(String.length(s), 125n) + v126 = Nat.add(String.length(s), 126n) + v127 = Nat.add(String.length(s), 127n) + v128 = Nat.add(String.length(s), 128n) + v129 = Nat.add(String.length(s), 129n) + v130 = Nat.add(String.length(s), 130n) + v131 = Nat.add(String.length(s), 131n) + v132 = Nat.add(String.length(s), 132n) + v133 = Nat.add(String.length(s), 133n) + v134 = Nat.add(String.length(s), 134n) + v135 = Nat.add(String.length(s), 135n) + v136 = Nat.add(String.length(s), 136n) + v137 = Nat.add(String.length(s), 137n) + v138 = Nat.add(String.length(s), 138n) + v139 = Nat.add(String.length(s), 139n) + v140 = Nat.add(String.length(s), 140n) + v141 = Nat.add(String.length(s), 141n) + v142 = Nat.add(String.length(s), 142n) + v143 = Nat.add(String.length(s), 143n) + v144 = Nat.add(String.length(s), 144n) + v145 = Nat.add(String.length(s), 145n) + v146 = Nat.add(String.length(s), 146n) + v147 = Nat.add(String.length(s), 147n) + v148 = Nat.add(String.length(s), 148n) + v149 = Nat.add(String.length(s), 149n) + v150 = Nat.add(String.length(s), 150n) + v151 = Nat.add(String.length(s), 151n) + v152 = Nat.add(String.length(s), 152n) + v153 = Nat.add(String.length(s), 153n) + v154 = Nat.add(String.length(s), 154n) + v155 = Nat.add(String.length(s), 155n) + v156 = Nat.add(String.length(s), 156n) + v157 = Nat.add(String.length(s), 157n) + v158 = Nat.add(String.length(s), 158n) + v159 = Nat.add(String.length(s), 159n) + v160 = Nat.add(String.length(s), 160n) + v161 = Nat.add(String.length(s), 161n) + v162 = Nat.add(String.length(s), 162n) + v163 = Nat.add(String.length(s), 163n) + v164 = Nat.add(String.length(s), 164n) + v165 = Nat.add(String.length(s), 165n) + v166 = Nat.add(String.length(s), 166n) + v167 = Nat.add(String.length(s), 167n) + v168 = Nat.add(String.length(s), 168n) + v169 = Nat.add(String.length(s), 169n) + v170 = Nat.add(String.length(s), 170n) + v171 = Nat.add(String.length(s), 171n) + v172 = Nat.add(String.length(s), 172n) + v173 = Nat.add(String.length(s), 173n) + v174 = Nat.add(String.length(s), 174n) + v175 = Nat.add(String.length(s), 175n) + v176 = Nat.add(String.length(s), 176n) + v177 = Nat.add(String.length(s), 177n) + v178 = Nat.add(String.length(s), 178n) + v179 = Nat.add(String.length(s), 179n) + v180 = Nat.add(String.length(s), 180n) + v181 = Nat.add(String.length(s), 181n) + v182 = Nat.add(String.length(s), 182n) + v183 = Nat.add(String.length(s), 183n) + v184 = Nat.add(String.length(s), 184n) + v185 = Nat.add(String.length(s), 185n) + v186 = Nat.add(String.length(s), 186n) + v187 = Nat.add(String.length(s), 187n) + v188 = Nat.add(String.length(s), 188n) + v189 = Nat.add(String.length(s), 189n) + v190 = Nat.add(String.length(s), 190n) + v191 = Nat.add(String.length(s), 191n) + v192 = Nat.add(String.length(s), 192n) + v193 = Nat.add(String.length(s), 193n) + v194 = Nat.add(String.length(s), 194n) + v195 = Nat.add(String.length(s), 195n) + v196 = Nat.add(String.length(s), 196n) + v197 = Nat.add(String.length(s), 197n) + v198 = Nat.add(String.length(s), 198n) + v199 = Nat.add(String.length(s), 199n) + v200 = Nat.add(String.length(s), 200n) + v201 = Nat.add(String.length(s), 201n) + v202 = Nat.add(String.length(s), 202n) + v203 = Nat.add(String.length(s), 203n) + v204 = Nat.add(String.length(s), 204n) + v205 = Nat.add(String.length(s), 205n) + v206 = Nat.add(String.length(s), 206n) + v207 = Nat.add(String.length(s), 207n) + v208 = Nat.add(String.length(s), 208n) + v209 = Nat.add(String.length(s), 209n) + v210 = Nat.add(String.length(s), 210n) + v211 = Nat.add(String.length(s), 211n) + v212 = Nat.add(String.length(s), 212n) + v213 = Nat.add(String.length(s), 213n) + v214 = Nat.add(String.length(s), 214n) + v215 = Nat.add(String.length(s), 215n) + v216 = Nat.add(String.length(s), 216n) + v217 = Nat.add(String.length(s), 217n) + v218 = Nat.add(String.length(s), 218n) + v219 = Nat.add(String.length(s), 219n) + v220 = Nat.add(String.length(s), 220n) + v221 = Nat.add(String.length(s), 221n) + v222 = Nat.add(String.length(s), 222n) + v223 = Nat.add(String.length(s), 223n) + v224 = Nat.add(String.length(s), 224n) + v225 = Nat.add(String.length(s), 225n) + v226 = Nat.add(String.length(s), 226n) + v227 = Nat.add(String.length(s), 227n) + v228 = Nat.add(String.length(s), 228n) + v229 = Nat.add(String.length(s), 229n) + v230 = Nat.add(String.length(s), 230n) + v231 = Nat.add(String.length(s), 231n) + v232 = Nat.add(String.length(s), 232n) + v233 = Nat.add(String.length(s), 233n) + v234 = Nat.add(String.length(s), 234n) + v235 = Nat.add(String.length(s), 235n) + v236 = Nat.add(String.length(s), 236n) + v237 = Nat.add(String.length(s), 237n) + v238 = Nat.add(String.length(s), 238n) + v239 = Nat.add(String.length(s), 239n) + v240 = Nat.add(String.length(s), 240n) + v241 = Nat.add(String.length(s), 241n) + v242 = Nat.add(String.length(s), 242n) + v243 = Nat.add(String.length(s), 243n) + v244 = Nat.add(String.length(s), 244n) + v245 = Nat.add(String.length(s), 245n) + v246 = Nat.add(String.length(s), 246n) + v247 = Nat.add(String.length(s), 247n) + v248 = Nat.add(String.length(s), 248n) + v249 = Nat.add(String.length(s), 249n) + v250 = Nat.add(String.length(s), 250n) + v251 = Nat.add(String.length(s), 251n) + v252 = Nat.add(String.length(s), 252n) + v253 = Nat.add(String.length(s), 253n) + v254 = Nat.add(String.length(s), 254n) + v255 = Nat.add(String.length(s), 255n) + v256 = Nat.add(String.length(s), 256n) + v257 = Nat.add(String.length(s), 257n) + v258 = Nat.add(String.length(s), 258n) + v259 = Nat.add(String.length(s), 259n) + v260 = Nat.add(String.length(s), 260n) + v261 = Nat.add(String.length(s), 261n) + v262 = Nat.add(String.length(s), 262n) + v263 = Nat.add(String.length(s), 263n) + v264 = Nat.add(String.length(s), 264n) + v265 = Nat.add(String.length(s), 265n) + v266 = Nat.add(String.length(s), 266n) + v267 = Nat.add(String.length(s), 267n) + v268 = Nat.add(String.length(s), 268n) + v269 = Nat.add(String.length(s), 269n) + v270 = Nat.add(String.length(s), 270n) + v271 = Nat.add(String.length(s), 271n) + v272 = Nat.add(String.length(s), 272n) + v273 = Nat.add(String.length(s), 273n) + v274 = Nat.add(String.length(s), 274n) + v275 = Nat.add(String.length(s), 275n) + v276 = Nat.add(String.length(s), 276n) + v277 = Nat.add(String.length(s), 277n) + v278 = Nat.add(String.length(s), 278n) + v279 = Nat.add(String.length(s), 279n) + v280 = Nat.add(String.length(s), 280n) + v281 = Nat.add(String.length(s), 281n) + v282 = Nat.add(String.length(s), 282n) + v283 = Nat.add(String.length(s), 283n) + v284 = Nat.add(String.length(s), 284n) + v285 = Nat.add(String.length(s), 285n) + v286 = Nat.add(String.length(s), 286n) + v287 = Nat.add(String.length(s), 287n) + v288 = Nat.add(String.length(s), 288n) + v289 = Nat.add(String.length(s), 289n) + v290 = Nat.add(String.length(s), 290n) + v291 = Nat.add(String.length(s), 291n) + v292 = Nat.add(String.length(s), 292n) + v293 = Nat.add(String.length(s), 293n) + v294 = Nat.add(String.length(s), 294n) + v295 = Nat.add(String.length(s), 295n) + v296 = Nat.add(String.length(s), 296n) + v297 = Nat.add(String.length(s), 297n) + v298 = Nat.add(String.length(s), 298n) + v299 = Nat.add(String.length(s), 299n) + result = rotate(n, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299) + base = Nat.sub(Nat.add(8999900n, Nat.mul(150n, Nat.mul(n, n))), Nat.mul(45000n, n)) + expected = Nat.add(Nat.mul(String.length(s), 45150n), base) + IO.print(Bool.show(Cmp.is_eq(Nat.cmp(result, expected)))) + +def main() -> IO(Unit): + do IO: + t: Nat <- IO.now() + consume(t) + +#| True From 86b99b8e621f5bbca3ece33a0aae2f041c5f0a3a Mon Sep 17 00:00:00 2001 From: oxura Date: Sun, 11 Oct 2026 19:52:06 +0600 Subject: [PATCH 2/2] chore: keep wide spill fix within the permanent compiler budget --- bend2/comp.ts | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/bend2/comp.ts b/bend2/comp.ts index b3e1ad8bc..d0f16bff7 100644 --- a/bend2/comp.ts +++ b/bend2/comp.ts @@ -1518,8 +1518,6 @@ function spare_flush(sc: Scope): void { // Seg // === -// Pop the frame and register spill before opening the parameters. - function seg_new(name: string, ret: Lay, params: string[], ks: Kind[] = [], frame: Seg["frame"] = null): Seg { return { fid: name && seg_fid(name), def: name, ret, lines: [], params, ks, @@ -1538,7 +1536,7 @@ function seg_take(seg: Seg): string[] { const { pop, at } = seg.frame ?? { pop: 0, at: [] }; const drop = pop + (seg.native ? 0 : Math.max(0, seg.params.length - at.length - WIDE)); - return [...drop > 0 ? [`WL_POPN(${drop});`] : [], ...seg.params.map((p, i) => + return [...drop ? [`WL_POPN(${drop});`] : [], ...seg.params.map((p, i) => `${lay_c(seg.ks[i])} ${p} = ${i < at.length ? `STK(${at[i]})` : seg_reg(seg, i - at.length, pop)};`)]; } @@ -2778,9 +2776,7 @@ function effect_srcs(ext: string, miss: string): string[] { // C // - -// The device holds bang-reachable segments and closure-taking bangs' closures. -// rp frees rax for host musttail. WL_LOAD's ladder avoids clang's quadratic -// phi cascade for a fallthrough switch. +// Bounded bank/ladder avoids quadratic clang phis; rp frees rax for musttail. export function compile_book(book: Bend.Book): string { FL = file_new(book, false); @@ -4372,8 +4368,6 @@ static Term work_loop(Env e, DEV Term* sp, Term t, u32 seq) { // Segments // ======== -// Parameters: continuation frames, otherwise the bank plus its spill tail. - ${segs} WL_CASE(FID_ENTER)