├── .github └── workflows │ └── moonbit.yml ├── .gitignore ├── .gitmodules ├── .moonbit-lsp.json ├── LICENSE ├── MiniMoonBit.g4 ├── TODO.md ├── bf.ml ├── bf.py ├── build_riscvrt.sh ├── build_rvlinux.sh ├── calc.py ├── conf.py ├── configure ├── default.json ├── disable_inline.json ├── disable_knf_opt.json ├── disable_opt.json └── disable_xthead.json ├── debug.sh ├── debug2.sh ├── debug3.sh ├── js_rt ├── runtime.mjs └── test.mjs ├── license ├── licenses └── mincaml ├── make_submit.sh ├── mmm.json ├── moon.mod.json ├── riscv_rt ├── .gitignore ├── README.md ├── build.zig ├── src │ ├── lib.zig │ └── start.zig └── test │ ├── float_int.s │ ├── malloc.s │ └── print_int.s ├── run-islec.sh ├── sort_gen.py ├── src ├── bin │ ├── bin.mbti │ ├── main.mbt │ └── moon.pkg.json ├── closure │ ├── closure.mbti │ ├── closure_ir.mbt │ ├── json.mbt │ ├── knf_to_closure.mbt │ ├── lowtype.mbt │ └── moon.pkg.json ├── closure_eval │ ├── closure_eval.mbti │ ├── interpreter.mbt │ └── moon.pkg.json ├── core │ ├── core.isle │ ├── core.mbt │ ├── core.mbti │ ├── knf_to_core.mbt │ ├── knf_to_core_test.mbt │ ├── moon.pkg.json │ ├── prelude.isle │ └── pretty_print.mbt ├── core_analysis │ ├── call_analysis.mbt │ ├── core_analysis.mbti │ ├── defs.mbt │ ├── dfs.mbt │ ├── dom.mbt │ ├── dom_test.mbt │ ├── moon.pkg.json │ ├── pred.mbt │ └── use.mbt ├── core_eval │ ├── core_eval.mbti │ ├── fast_interp.txt │ ├── interpreter.mbt │ └── moon.pkg.json ├── core_opt │ ├── core_opt.mbt │ ├── core_opt.mbti │ ├── fo.mbt │ ├── inline.mbt │ ├── jtbl.mbt │ ├── licm.mbt │ ├── lvn.mbt │ ├── moon.pkg.json │ ├── o2f.mbt │ ├── rename.mbt │ └── tre.mbt ├── knf │ ├── free.mbt │ ├── inline.mbt │ ├── json.mbt │ ├── knf.mbt │ ├── knf.mbti │ ├── licm.mbt │ ├── lift.mbt │ ├── moon.pkg.json │ ├── pattern_matcher.mbt │ ├── pattern_matcher_test.mbt │ ├── pretty_print.mbt │ ├── syntax_preproceess.mbt │ ├── syntax_to_knf.mbt │ ├── unbox.mbt │ └── utils.mbt ├── knf_eval │ ├── interpreter.mbt │ ├── knf_eval.mbti │ └── moon.pkg.json ├── lexer │ ├── lexer.mbt │ ├── lexer.mbti │ ├── lexer_test.mbt │ └── moon.pkg.json ├── lower │ ├── js │ │ ├── js.mbti │ │ ├── jscore.mbt │ │ ├── lower.mbt │ │ └── moon.pkg.json │ ├── lower.mbti │ ├── moon.pkg.json │ ├── order.mbt │ ├── order_test.mbt │ ├── ppalloc.mbt │ ├── riscv │ │ ├── generated │ │ │ ├── generated.mbt │ │ │ ├── generated.mbti │ │ │ └── moon.pkg.json │ │ ├── liveness.mbt │ │ ├── lower.isle │ │ ├── lower.mbt │ │ ├── mcore.mbt │ │ ├── moon.pkg.json │ │ ├── regalloc.mbt │ │ └── riscv.mbti │ └── wasm │ │ ├── lower.mbt │ │ ├── moon.pkg.json │ │ ├── wasm.mbt │ │ └── wasm.mbti ├── magic │ ├── magic.mbt │ ├── magic.mbti │ └── moon.pkg.json ├── minimbt.mbti ├── moon.pkg.json ├── name.mbt ├── parser │ ├── moon.pkg.json │ ├── parser.mbt │ ├── parser.mbti │ └── parser_test.mbt ├── riscv │ ├── asm_stringify.mbt │ ├── emit.mbt │ ├── moon.pkg.json │ ├── reg.mbt │ ├── riscv.isle │ ├── riscv.mbti │ └── rv_asm.mbt ├── top.mbt ├── typer │ ├── moon.pkg.json │ ├── typer.mbt │ ├── typer.mbti │ └── typer_test.mbt ├── util │ ├── error.mbt │ ├── indent_logger.mbt │ ├── moon.pkg.json │ ├── tohex.mbt │ ├── trace.mbt │ └── util.mbti └── utils.mbt ├── start-rvvm.sh ├── submit.sh ├── subst.py ├── test-ext.log ├── test-ext.sh ├── test-js.log ├── test-js.sh ├── test-rv.log ├── test-rv.sh ├── test-size.log ├── test-size.sh ├── test-wasm.sh ├── test.sh ├── test ├── .gitignore ├── longer-cases │ ├── bf.core_opt2_after_fo.txt │ ├── bf.core_opt2_after_jtbl.txt │ ├── bf.core_opt2_after_lvn.txt │ ├── bf.core_opt_after_dfe_0.txt │ ├── bf.core_opt_after_dfe_1.txt │ ├── bf.core_opt_after_dfe_2.txt │ ├── bf.core_opt_after_inline_0.txt │ ├── bf.core_opt_after_inline_1.txt │ ├── bf.core_opt_after_inline_2.txt │ ├── bf.core_opt_after_licm.txt │ ├── bf.core_opt_after_lvn.txt │ ├── bf.core_opt_after_o2f.txt │ ├── bf.core_opt_after_splitted_0.txt │ ├── bf.core_opt_after_splitted_1.txt │ ├── bf.core_opt_after_splitted_2.txt │ ├── bf.core_opt_after_tre.txt │ ├── bf.free_set_closure.txt │ ├── bf.freg.txt │ ├── bf.knf.txt │ ├── bf.knf_after_inline_0.txt │ ├── bf.knf_after_inline_1.txt │ ├── bf.knf_after_inline_2.txt │ ├── bf.knf_after_licm_0.txt │ ├── bf.knf_after_licm_1.txt │ ├── bf.knf_after_licm_2.txt │ ├── bf.knf_after_lifting.txt │ ├── bf.knf_after_unbox.txt │ ├── bf.knf_to_core.txt │ ├── bf.log │ ├── bf.mbt │ ├── bf.mcore.txt │ ├── bf.resolved.txt │ ├── bf.typer.txt │ ├── bf.typer_simplified.txt │ ├── bf.xreg.txt │ ├── fannkuch-redux.core_opt2_after_fo.txt │ ├── fannkuch-redux.core_opt2_after_jtbl.txt │ ├── fannkuch-redux.core_opt2_after_lvn.txt │ ├── fannkuch-redux.core_opt_after_dfe_0.txt │ ├── fannkuch-redux.core_opt_after_dfe_1.txt │ ├── fannkuch-redux.core_opt_after_dfe_2.txt │ ├── fannkuch-redux.core_opt_after_inline_0.txt │ ├── fannkuch-redux.core_opt_after_inline_1.txt │ ├── fannkuch-redux.core_opt_after_inline_2.txt │ ├── fannkuch-redux.core_opt_after_licm.txt │ ├── fannkuch-redux.core_opt_after_lvn.txt │ ├── fannkuch-redux.core_opt_after_o2f.txt │ ├── fannkuch-redux.core_opt_after_splitted_0.txt │ ├── fannkuch-redux.core_opt_after_splitted_1.txt │ ├── fannkuch-redux.core_opt_after_splitted_2.txt │ ├── fannkuch-redux.core_opt_after_tre.txt │ ├── fannkuch-redux.free_set_closure.txt │ ├── fannkuch-redux.freg.txt │ ├── fannkuch-redux.knf.txt │ ├── fannkuch-redux.knf_after_inline_0.txt │ ├── fannkuch-redux.knf_after_inline_1.txt │ ├── fannkuch-redux.knf_after_inline_2.txt │ ├── fannkuch-redux.knf_after_licm_0.txt │ ├── fannkuch-redux.knf_after_licm_1.txt │ ├── fannkuch-redux.knf_after_licm_2.txt │ ├── fannkuch-redux.knf_after_lifting.txt │ ├── fannkuch-redux.knf_after_unbox.txt │ ├── fannkuch-redux.knf_to_core.txt │ ├── fannkuch-redux.log │ ├── fannkuch-redux.mbt │ ├── fannkuch-redux.mcore.txt │ ├── fannkuch-redux.resolved.txt │ ├── fannkuch-redux.typer.txt │ ├── fannkuch-redux.typer_simplified.txt │ ├── fannkuch-redux.xreg.txt │ ├── generic.free_set_closure.txt │ ├── generic.knf.txt │ ├── generic.knf_after_inline_0.txt │ ├── generic.knf_after_inline_1.txt │ ├── generic.knf_after_inline_2.txt │ ├── generic.knf_after_licm_0.txt │ ├── generic.knf_after_licm_1.txt │ ├── generic.knf_after_licm_2.txt │ ├── generic.knf_after_lifting.txt │ ├── generic.knf_after_unbox.txt │ ├── generic.log │ ├── generic.mbt │ ├── generic.resolved.txt │ ├── generic.typer.txt │ ├── generic.typer_simplified.txt │ ├── isort.ans │ ├── isort.core_opt2_after_fo.txt │ ├── isort.core_opt2_after_jtbl.txt │ ├── isort.core_opt2_after_lvn.txt │ ├── isort.core_opt_after_dfe_0.txt │ ├── isort.core_opt_after_dfe_1.txt │ ├── isort.core_opt_after_dfe_2.txt │ ├── isort.core_opt_after_inline_0.txt │ ├── isort.core_opt_after_inline_1.txt │ ├── isort.core_opt_after_inline_2.txt │ ├── isort.core_opt_after_licm.txt │ ├── isort.core_opt_after_lvn.txt │ ├── isort.core_opt_after_o2f.txt │ ├── isort.core_opt_after_splitted_0.txt │ ├── isort.core_opt_after_splitted_1.txt │ ├── isort.core_opt_after_splitted_2.txt │ ├── isort.core_opt_after_tre.txt │ ├── isort.free_set_closure.txt │ ├── isort.freg.txt │ ├── isort.in │ ├── isort.knf.txt │ ├── isort.knf_after_inline_0.txt │ ├── isort.knf_after_inline_1.txt │ ├── isort.knf_after_inline_2.txt │ ├── isort.knf_after_licm_0.txt │ ├── isort.knf_after_licm_1.txt │ ├── isort.knf_after_licm_2.txt │ ├── isort.knf_after_lifting.txt │ ├── isort.knf_after_unbox.txt │ ├── isort.knf_to_core.txt │ ├── isort.log │ ├── isort.mbt │ ├── isort.mcore.txt │ ├── isort.resolved.txt │ ├── isort.typer.txt │ ├── isort.typer_simplified.txt │ ├── isort.xreg.txt │ ├── iter.core_opt2_after_fo.txt │ ├── iter.core_opt2_after_jtbl.txt │ ├── iter.core_opt2_after_lvn.txt │ ├── iter.core_opt_after_dfe_0.txt │ ├── iter.core_opt_after_dfe_1.txt │ ├── iter.core_opt_after_dfe_2.txt │ ├── iter.core_opt_after_inline_0.txt │ ├── iter.core_opt_after_inline_1.txt │ ├── iter.core_opt_after_inline_2.txt │ ├── iter.core_opt_after_licm.txt │ ├── iter.core_opt_after_lvn.txt │ ├── iter.core_opt_after_o2f.txt │ ├── iter.core_opt_after_splitted_0.txt │ ├── iter.core_opt_after_splitted_1.txt │ ├── iter.core_opt_after_splitted_2.txt │ ├── iter.core_opt_after_tre.txt │ ├── iter.free_set_closure.txt │ ├── iter.freg.txt │ ├── iter.knf.txt │ ├── iter.knf_after_inline_0.txt │ ├── iter.knf_after_inline_1.txt │ ├── iter.knf_after_inline_2.txt │ ├── iter.knf_after_licm_0.txt │ ├── iter.knf_after_licm_1.txt │ ├── iter.knf_after_licm_2.txt │ ├── iter.knf_after_lifting.txt │ ├── iter.knf_after_unbox.txt │ ├── iter.knf_to_core.txt │ ├── iter.log │ ├── iter.mbt │ ├── iter.mcore.txt │ ├── iter.resolved.txt │ ├── iter.typer.txt │ ├── iter.typer_simplified.txt │ ├── iter.xreg.txt │ ├── julia.ans │ ├── julia.core_opt2_after_fo.txt │ ├── julia.core_opt2_after_jtbl.txt │ ├── julia.core_opt2_after_lvn.txt │ ├── julia.core_opt_after_dfe_0.txt │ ├── julia.core_opt_after_dfe_1.txt │ ├── julia.core_opt_after_dfe_2.txt │ ├── julia.core_opt_after_inline_0.txt │ ├── julia.core_opt_after_inline_1.txt │ ├── julia.core_opt_after_inline_2.txt │ ├── julia.core_opt_after_licm.txt │ ├── julia.core_opt_after_lvn.txt │ ├── julia.core_opt_after_o2f.txt │ ├── julia.core_opt_after_splitted_0.txt │ ├── julia.core_opt_after_splitted_1.txt │ ├── julia.core_opt_after_splitted_2.txt │ ├── julia.core_opt_after_tre.txt │ ├── julia.free_set_closure.txt │ ├── julia.freg.txt │ ├── julia.in │ ├── julia.knf.txt │ ├── julia.knf_after_inline_0.txt │ ├── julia.knf_after_inline_1.txt │ ├── julia.knf_after_inline_2.txt │ ├── julia.knf_after_licm_0.txt │ ├── julia.knf_after_licm_1.txt │ ├── julia.knf_after_licm_2.txt │ ├── julia.knf_after_lifting.txt │ ├── julia.knf_after_unbox.txt │ ├── julia.knf_to_core.txt │ ├── julia.log │ ├── julia.mbt │ ├── julia.mcore.txt │ ├── julia.resolved.txt │ ├── julia.typer.txt │ ├── julia.typer_simplified.txt │ ├── julia.xreg.txt │ ├── mem-fib.ans │ ├── mem-fib.core_opt2_after_fo.txt │ ├── mem-fib.core_opt2_after_jtbl.txt │ ├── mem-fib.core_opt2_after_lvn.txt │ ├── mem-fib.core_opt_after_dfe_0.txt │ ├── mem-fib.core_opt_after_dfe_1.txt │ ├── mem-fib.core_opt_after_dfe_2.txt │ ├── mem-fib.core_opt_after_inline_0.txt │ ├── mem-fib.core_opt_after_inline_1.txt │ ├── mem-fib.core_opt_after_inline_2.txt │ ├── mem-fib.core_opt_after_licm.txt │ ├── mem-fib.core_opt_after_lvn.txt │ ├── mem-fib.core_opt_after_o2f.txt │ ├── mem-fib.core_opt_after_splitted_0.txt │ ├── mem-fib.core_opt_after_splitted_1.txt │ ├── mem-fib.core_opt_after_splitted_2.txt │ ├── mem-fib.core_opt_after_tre.txt │ ├── mem-fib.free_set_closure.txt │ ├── mem-fib.freg.txt │ ├── mem-fib.in │ ├── mem-fib.knf.txt │ ├── mem-fib.knf_after_inline_0.txt │ ├── mem-fib.knf_after_inline_1.txt │ ├── mem-fib.knf_after_inline_2.txt │ ├── mem-fib.knf_after_licm_0.txt │ ├── mem-fib.knf_after_licm_1.txt │ ├── mem-fib.knf_after_licm_2.txt │ ├── mem-fib.knf_after_lifting.txt │ ├── mem-fib.knf_after_unbox.txt │ ├── mem-fib.knf_to_core.txt │ ├── mem-fib.log │ ├── mem-fib.mbt │ ├── mem-fib.mcore.txt │ ├── mem-fib.resolved.txt │ ├── mem-fib.typer.txt │ ├── mem-fib.typer_simplified.txt │ ├── mem-fib.xreg.txt │ ├── phi.core_opt2_after_fo.txt │ ├── phi.core_opt2_after_jtbl.txt │ ├── phi.core_opt2_after_lvn.txt │ ├── phi.core_opt_after_dfe_0.txt │ ├── phi.core_opt_after_dfe_1.txt │ ├── phi.core_opt_after_dfe_2.txt │ ├── phi.core_opt_after_inline_0.txt │ ├── phi.core_opt_after_inline_1.txt │ ├── phi.core_opt_after_inline_2.txt │ ├── phi.core_opt_after_licm.txt │ ├── phi.core_opt_after_lvn.txt │ ├── phi.core_opt_after_o2f.txt │ ├── phi.core_opt_after_splitted_0.txt │ ├── phi.core_opt_after_splitted_1.txt │ ├── phi.core_opt_after_splitted_2.txt │ ├── phi.core_opt_after_tre.txt │ ├── phi.free_set_closure.txt │ ├── phi.freg.txt │ ├── phi.knf.txt │ ├── phi.knf_after_inline_0.txt │ ├── phi.knf_after_inline_1.txt │ ├── phi.knf_after_inline_2.txt │ ├── phi.knf_after_licm_0.txt │ ├── phi.knf_after_licm_1.txt │ ├── phi.knf_after_licm_2.txt │ ├── phi.knf_after_lifting.txt │ ├── phi.knf_after_unbox.txt │ ├── phi.knf_to_core.txt │ ├── phi.log │ ├── phi.mbt │ ├── phi.mcore.txt │ ├── phi.resolved.txt │ ├── phi.typer.txt │ ├── phi.typer_simplified.txt │ ├── phi.xreg.txt │ ├── quicksort-std.core_opt2_after_fo.txt │ ├── quicksort-std.core_opt2_after_jtbl.txt │ ├── quicksort-std.core_opt2_after_lvn.txt │ ├── quicksort-std.core_opt_after_dfe_0.txt │ ├── quicksort-std.core_opt_after_dfe_1.txt │ ├── quicksort-std.core_opt_after_dfe_2.txt │ ├── quicksort-std.core_opt_after_inline_0.txt │ ├── quicksort-std.core_opt_after_inline_1.txt │ ├── quicksort-std.core_opt_after_inline_2.txt │ ├── quicksort-std.core_opt_after_licm.txt │ ├── quicksort-std.core_opt_after_lvn.txt │ ├── quicksort-std.core_opt_after_o2f.txt │ ├── quicksort-std.core_opt_after_splitted_0.txt │ ├── quicksort-std.core_opt_after_splitted_1.txt │ ├── quicksort-std.core_opt_after_splitted_2.txt │ ├── quicksort-std.core_opt_after_tre.txt │ ├── quicksort-std.free_set_closure.txt │ ├── quicksort-std.freg.txt │ ├── quicksort-std.knf.txt │ ├── quicksort-std.knf_after_inline_0.txt │ ├── quicksort-std.knf_after_inline_1.txt │ ├── quicksort-std.knf_after_inline_2.txt │ ├── quicksort-std.knf_after_licm_0.txt │ ├── quicksort-std.knf_after_licm_1.txt │ ├── quicksort-std.knf_after_licm_2.txt │ ├── quicksort-std.knf_after_lifting.txt │ ├── quicksort-std.knf_after_unbox.txt │ ├── quicksort-std.knf_to_core.txt │ ├── quicksort-std.log │ ├── quicksort-std.mbt │ ├── quicksort-std.mcore.txt │ ├── quicksort-std.resolved.txt │ ├── quicksort-std.typer.txt │ ├── quicksort-std.typer_simplified.txt │ ├── quicksort-std.xreg.txt │ ├── quicksort.core_opt2_after_fo.txt │ ├── quicksort.core_opt2_after_jtbl.txt │ ├── quicksort.core_opt2_after_lvn.txt │ ├── quicksort.core_opt_after_dfe_0.txt │ ├── quicksort.core_opt_after_dfe_1.txt │ ├── quicksort.core_opt_after_dfe_2.txt │ ├── quicksort.core_opt_after_inline_0.txt │ ├── quicksort.core_opt_after_inline_1.txt │ ├── quicksort.core_opt_after_inline_2.txt │ ├── quicksort.core_opt_after_licm.txt │ ├── quicksort.core_opt_after_lvn.txt │ ├── quicksort.core_opt_after_o2f.txt │ ├── quicksort.core_opt_after_splitted_0.txt │ ├── quicksort.core_opt_after_splitted_1.txt │ ├── quicksort.core_opt_after_splitted_2.txt │ ├── quicksort.core_opt_after_tre.txt │ ├── quicksort.free_set_closure.txt │ ├── quicksort.freg.txt │ ├── quicksort.knf.txt │ ├── quicksort.knf_after_inline_0.txt │ ├── quicksort.knf_after_inline_1.txt │ ├── quicksort.knf_after_inline_2.txt │ ├── quicksort.knf_after_licm_0.txt │ ├── quicksort.knf_after_licm_1.txt │ ├── quicksort.knf_after_licm_2.txt │ ├── quicksort.knf_after_lifting.txt │ ├── quicksort.knf_after_unbox.txt │ ├── quicksort.knf_to_core.txt │ ├── quicksort.log │ ├── quicksort.mbt │ ├── quicksort.mcore.txt │ ├── quicksort.resolved.txt │ ├── quicksort.typer.txt │ ├── quicksort.typer_simplified.txt │ ├── quicksort.xreg.txt │ ├── stream.ans │ ├── stream.core_opt2_after_fo.txt │ ├── stream.core_opt2_after_jtbl.txt │ ├── stream.core_opt2_after_lvn.txt │ ├── stream.core_opt_after_dfe_0.txt │ ├── stream.core_opt_after_dfe_1.txt │ ├── stream.core_opt_after_dfe_2.txt │ ├── stream.core_opt_after_inline_0.txt │ ├── stream.core_opt_after_inline_1.txt │ ├── stream.core_opt_after_inline_2.txt │ ├── stream.core_opt_after_licm.txt │ ├── stream.core_opt_after_lvn.txt │ ├── stream.core_opt_after_o2f.txt │ ├── stream.core_opt_after_splitted_0.txt │ ├── stream.core_opt_after_splitted_1.txt │ ├── stream.core_opt_after_splitted_2.txt │ ├── stream.core_opt_after_tre.txt │ ├── stream.free_set_closure.txt │ ├── stream.freg.txt │ ├── stream.in │ ├── stream.knf.txt │ ├── stream.knf_after_inline_0.txt │ ├── stream.knf_after_inline_1.txt │ ├── stream.knf_after_inline_2.txt │ ├── stream.knf_after_licm_0.txt │ ├── stream.knf_after_licm_1.txt │ ├── stream.knf_after_licm_2.txt │ ├── stream.knf_after_lifting.txt │ ├── stream.knf_after_unbox.txt │ ├── stream.knf_to_core.txt │ ├── stream.log │ ├── stream.mbt │ ├── stream.mcore.txt │ ├── stream.resolved.txt │ ├── stream.typer.txt │ ├── stream.typer_simplified.txt │ └── stream.xreg.txt ├── more-tests │ ├── nbody.ans │ ├── nbody.core_opt2_after_fo.txt │ ├── nbody.core_opt2_after_jtbl.txt │ ├── nbody.core_opt2_after_lvn.txt │ ├── nbody.core_opt_after_dfe_0.txt │ ├── nbody.core_opt_after_dfe_1.txt │ ├── nbody.core_opt_after_dfe_2.txt │ ├── nbody.core_opt_after_inline_0.txt │ ├── nbody.core_opt_after_inline_1.txt │ ├── nbody.core_opt_after_inline_2.txt │ ├── nbody.core_opt_after_licm.txt │ ├── nbody.core_opt_after_lvn.txt │ ├── nbody.core_opt_after_o2f.txt │ ├── nbody.core_opt_after_splitted_0.txt │ ├── nbody.core_opt_after_splitted_1.txt │ ├── nbody.core_opt_after_splitted_2.txt │ ├── nbody.core_opt_after_tre.txt │ ├── nbody.free_set_closure.txt │ ├── nbody.freg.txt │ ├── nbody.knf.txt │ ├── nbody.knf_after_inline_0.txt │ ├── nbody.knf_after_inline_1.txt │ ├── nbody.knf_after_inline_2.txt │ ├── nbody.knf_after_licm_0.txt │ ├── nbody.knf_after_licm_1.txt │ ├── nbody.knf_after_licm_2.txt │ ├── nbody.knf_after_lifting.txt │ ├── nbody.knf_after_unbox.txt │ ├── nbody.knf_to_core.txt │ ├── nbody.log │ ├── nbody.mbt │ ├── nbody.mcore.txt │ ├── nbody.resolved.txt │ ├── nbody.typer.txt │ ├── nbody.typer_simplified.txt │ ├── nbody.xreg.txt │ ├── prelude.core_opt2_after_fo.txt │ ├── prelude.core_opt2_after_jtbl.txt │ ├── prelude.core_opt2_after_lvn.txt │ ├── prelude.core_opt_after_dfe_0.txt │ ├── prelude.core_opt_after_dfe_1.txt │ ├── prelude.core_opt_after_dfe_2.txt │ ├── prelude.core_opt_after_inline_0.txt │ ├── prelude.core_opt_after_inline_1.txt │ ├── prelude.core_opt_after_inline_2.txt │ ├── prelude.core_opt_after_licm.txt │ ├── prelude.core_opt_after_lvn.txt │ ├── prelude.core_opt_after_o2f.txt │ ├── prelude.core_opt_after_splitted_0.txt │ ├── prelude.core_opt_after_splitted_1.txt │ ├── prelude.core_opt_after_splitted_2.txt │ ├── prelude.core_opt_after_tre.txt │ ├── prelude.free_set_closure.txt │ ├── prelude.knf.txt │ ├── prelude.knf_after_inline_0.txt │ ├── prelude.knf_after_inline_1.txt │ ├── prelude.knf_after_inline_2.txt │ ├── prelude.knf_after_licm_0.txt │ ├── prelude.knf_after_licm_1.txt │ ├── prelude.knf_after_licm_2.txt │ ├── prelude.knf_after_lifting.txt │ ├── prelude.knf_after_unbox.txt │ ├── prelude.knf_to_core.txt │ ├── prelude.log │ ├── prelude.mbt │ ├── prelude.mcore.txt │ ├── prelude.resolved.txt │ ├── prelude.typer.txt │ ├── prelude.typer_simplified.txt │ ├── simd-large.ans │ ├── simd-large.core_opt2_after_fo.txt │ ├── simd-large.core_opt2_after_jtbl.txt │ ├── simd-large.core_opt2_after_lvn.txt │ ├── simd-large.core_opt_after_dfe_0.txt │ ├── simd-large.core_opt_after_dfe_1.txt │ ├── simd-large.core_opt_after_dfe_2.txt │ ├── simd-large.core_opt_after_inline_0.txt │ ├── simd-large.core_opt_after_inline_1.txt │ ├── simd-large.core_opt_after_inline_2.txt │ ├── simd-large.core_opt_after_licm.txt │ ├── simd-large.core_opt_after_lvn.txt │ ├── simd-large.core_opt_after_o2f.txt │ ├── simd-large.core_opt_after_splitted_0.txt │ ├── simd-large.core_opt_after_splitted_1.txt │ ├── simd-large.core_opt_after_splitted_2.txt │ ├── simd-large.core_opt_after_tre.txt │ ├── simd-large.free_set_closure.txt │ ├── simd-large.freg.txt │ ├── simd-large.knf.txt │ ├── simd-large.knf_after_inline_0.txt │ ├── simd-large.knf_after_inline_1.txt │ ├── simd-large.knf_after_inline_2.txt │ ├── simd-large.knf_after_licm_0.txt │ ├── simd-large.knf_after_licm_1.txt │ ├── simd-large.knf_after_licm_2.txt │ ├── simd-large.knf_after_lifting.txt │ ├── simd-large.knf_after_unbox.txt │ ├── simd-large.knf_to_core.txt │ ├── simd-large.log │ ├── simd-large.mbt │ ├── simd-large.mcore.txt │ ├── simd-large.resolved.txt │ ├── simd-large.typer.txt │ ├── simd-large.typer_simplified.txt │ └── simd-large.xreg.txt └── test_src │ ├── .gitignore │ ├── ack.ans │ ├── ack.core_opt2_after_fo.txt │ ├── ack.core_opt2_after_jtbl.txt │ ├── ack.core_opt2_after_lvn.txt │ ├── ack.core_opt_after_dfe_0.txt │ ├── ack.core_opt_after_dfe_1.txt │ ├── ack.core_opt_after_dfe_2.txt │ ├── ack.core_opt_after_inline_0.txt │ ├── ack.core_opt_after_inline_1.txt │ ├── ack.core_opt_after_inline_2.txt │ ├── ack.core_opt_after_licm.txt │ ├── ack.core_opt_after_lvn.txt │ ├── ack.core_opt_after_o2f.txt │ ├── ack.core_opt_after_splitted_0.txt │ ├── ack.core_opt_after_splitted_1.txt │ ├── ack.core_opt_after_splitted_2.txt │ ├── ack.core_opt_after_tre.txt │ ├── ack.free_set_closure.txt │ ├── ack.freg.txt │ ├── ack.knf.txt │ ├── ack.knf_after_inline_0.txt │ ├── ack.knf_after_inline_1.txt │ ├── ack.knf_after_inline_2.txt │ ├── ack.knf_after_licm_0.txt │ ├── ack.knf_after_licm_1.txt │ ├── ack.knf_after_licm_2.txt │ ├── ack.knf_after_lifting.txt │ ├── ack.knf_after_unbox.txt │ ├── ack.knf_to_core.txt │ ├── ack.log │ ├── ack.mbt │ ├── ack.mcore.txt │ ├── ack.resolved.txt │ ├── ack.typer.txt │ ├── ack.typer_simplified.txt │ ├── ack.xreg.txt │ ├── adder-double.core_opt2_after_fo.txt │ ├── adder-double.core_opt2_after_jtbl.txt │ ├── adder-double.core_opt2_after_lvn.txt │ ├── adder-double.core_opt_after_dfe_0.txt │ ├── adder-double.core_opt_after_dfe_1.txt │ ├── adder-double.core_opt_after_dfe_2.txt │ ├── adder-double.core_opt_after_inline_0.txt │ ├── adder-double.core_opt_after_inline_1.txt │ ├── adder-double.core_opt_after_inline_2.txt │ ├── adder-double.core_opt_after_licm.txt │ ├── adder-double.core_opt_after_lvn.txt │ ├── adder-double.core_opt_after_o2f.txt │ ├── adder-double.core_opt_after_splitted_0.txt │ ├── adder-double.core_opt_after_splitted_1.txt │ ├── adder-double.core_opt_after_splitted_2.txt │ ├── adder-double.core_opt_after_tre.txt │ ├── adder-double.free_set_closure.txt │ ├── adder-double.freg.txt │ ├── adder-double.knf.txt │ ├── adder-double.knf_after_inline_0.txt │ ├── adder-double.knf_after_inline_1.txt │ ├── adder-double.knf_after_inline_2.txt │ ├── adder-double.knf_after_licm_0.txt │ ├── adder-double.knf_after_licm_1.txt │ ├── adder-double.knf_after_licm_2.txt │ ├── adder-double.knf_after_lifting.txt │ ├── adder-double.knf_after_unbox.txt │ ├── adder-double.knf_to_core.txt │ ├── adder-double.log │ ├── adder-double.mbt │ ├── adder-double.mcore.txt │ ├── adder-double.resolved.txt │ ├── adder-double.typer.txt │ ├── adder-double.typer_simplified.txt │ ├── adder-double.xreg.txt │ ├── adder.ans │ ├── adder.core_opt2_after_fo.txt │ ├── adder.core_opt2_after_jtbl.txt │ ├── adder.core_opt2_after_lvn.txt │ ├── adder.core_opt_after_dfe_0.txt │ ├── adder.core_opt_after_dfe_1.txt │ ├── adder.core_opt_after_dfe_2.txt │ ├── adder.core_opt_after_inline_0.txt │ ├── adder.core_opt_after_inline_1.txt │ ├── adder.core_opt_after_inline_2.txt │ ├── adder.core_opt_after_licm.txt │ ├── adder.core_opt_after_lvn.txt │ ├── adder.core_opt_after_o2f.txt │ ├── adder.core_opt_after_splitted_0.txt │ ├── adder.core_opt_after_splitted_1.txt │ ├── adder.core_opt_after_splitted_2.txt │ ├── adder.core_opt_after_tre.txt │ ├── adder.free_set_closure.txt │ ├── adder.freg.txt │ ├── adder.knf.txt │ ├── adder.knf_after_inline_0.txt │ ├── adder.knf_after_inline_1.txt │ ├── adder.knf_after_inline_2.txt │ ├── adder.knf_after_licm_0.txt │ ├── adder.knf_after_licm_1.txt │ ├── adder.knf_after_licm_2.txt │ ├── adder.knf_after_lifting.txt │ ├── adder.knf_after_unbox.txt │ ├── adder.knf_to_core.txt │ ├── adder.log │ ├── adder.mbt │ ├── adder.mcore.txt │ ├── adder.resolved.txt │ ├── adder.typer.txt │ ├── adder.typer_simplified.txt │ ├── adder.xreg.txt │ ├── adder2.ans │ ├── adder2.core_opt2_after_fo.txt │ ├── adder2.core_opt2_after_jtbl.txt │ ├── adder2.core_opt2_after_lvn.txt │ ├── adder2.core_opt_after_dfe_0.txt │ ├── adder2.core_opt_after_dfe_1.txt │ ├── adder2.core_opt_after_dfe_2.txt │ ├── adder2.core_opt_after_inline_0.txt │ ├── adder2.core_opt_after_inline_1.txt │ ├── adder2.core_opt_after_inline_2.txt │ ├── adder2.core_opt_after_licm.txt │ ├── adder2.core_opt_after_lvn.txt │ ├── adder2.core_opt_after_o2f.txt │ ├── adder2.core_opt_after_splitted_0.txt │ ├── adder2.core_opt_after_splitted_1.txt │ ├── adder2.core_opt_after_splitted_2.txt │ ├── adder2.core_opt_after_tre.txt │ ├── adder2.free_set_closure.txt │ ├── adder2.freg.txt │ ├── adder2.knf.txt │ ├── adder2.knf_after_inline_0.txt │ ├── adder2.knf_after_inline_1.txt │ ├── adder2.knf_after_inline_2.txt │ ├── adder2.knf_after_licm_0.txt │ ├── adder2.knf_after_licm_1.txt │ ├── adder2.knf_after_licm_2.txt │ ├── adder2.knf_after_lifting.txt │ ├── adder2.knf_after_unbox.txt │ ├── adder2.knf_to_core.txt │ ├── adder2.log │ ├── adder2.mbt │ ├── adder2.mcore.txt │ ├── adder2.resolved.txt │ ├── adder2.typer.txt │ ├── adder2.typer_simplified.txt │ ├── adder2.xreg.txt │ ├── adt.knf.txt │ ├── adt.log │ ├── adt.mbt │ ├── adt.resolved.txt │ ├── adt.typer.txt │ ├── adt.typer_simplified.txt │ ├── array_literal.knf.txt │ ├── array_literal.log │ ├── array_literal.mbt │ ├── array_literal.resolved.txt │ ├── array_literal.typer.txt │ ├── array_literal.typer_simplified.txt │ ├── cls-bug.ans │ ├── cls-bug.core_opt2_after_fo.txt │ ├── cls-bug.core_opt2_after_jtbl.txt │ ├── cls-bug.core_opt2_after_lvn.txt │ ├── cls-bug.core_opt_after_dfe_0.txt │ ├── cls-bug.core_opt_after_dfe_1.txt │ ├── cls-bug.core_opt_after_dfe_2.txt │ ├── cls-bug.core_opt_after_inline_0.txt │ ├── cls-bug.core_opt_after_inline_1.txt │ ├── cls-bug.core_opt_after_inline_2.txt │ ├── cls-bug.core_opt_after_licm.txt │ ├── cls-bug.core_opt_after_lvn.txt │ ├── cls-bug.core_opt_after_o2f.txt │ ├── cls-bug.core_opt_after_splitted_0.txt │ ├── cls-bug.core_opt_after_splitted_1.txt │ ├── cls-bug.core_opt_after_splitted_2.txt │ ├── cls-bug.core_opt_after_tre.txt │ ├── cls-bug.free_set_closure.txt │ ├── cls-bug.freg.txt │ ├── cls-bug.knf.txt │ ├── cls-bug.knf_after_inline_0.txt │ ├── cls-bug.knf_after_inline_1.txt │ ├── cls-bug.knf_after_inline_2.txt │ ├── cls-bug.knf_after_licm_0.txt │ ├── cls-bug.knf_after_licm_1.txt │ ├── cls-bug.knf_after_licm_2.txt │ ├── cls-bug.knf_after_lifting.txt │ ├── cls-bug.knf_after_unbox.txt │ ├── cls-bug.knf_to_core.txt │ ├── cls-bug.log │ ├── cls-bug.mbt │ ├── cls-bug.mcore.txt │ ├── cls-bug.resolved.txt │ ├── cls-bug.typer.txt │ ├── cls-bug.typer_simplified.txt │ ├── cls-bug.xreg.txt │ ├── cls-bug2.ans │ ├── cls-bug2.core_opt2_after_fo.txt │ ├── cls-bug2.core_opt2_after_jtbl.txt │ ├── cls-bug2.core_opt2_after_lvn.txt │ ├── cls-bug2.core_opt_after_dfe_0.txt │ ├── cls-bug2.core_opt_after_dfe_1.txt │ ├── cls-bug2.core_opt_after_dfe_2.txt │ ├── cls-bug2.core_opt_after_inline_0.txt │ ├── cls-bug2.core_opt_after_inline_1.txt │ ├── cls-bug2.core_opt_after_inline_2.txt │ ├── cls-bug2.core_opt_after_licm.txt │ ├── cls-bug2.core_opt_after_lvn.txt │ ├── cls-bug2.core_opt_after_o2f.txt │ ├── cls-bug2.core_opt_after_splitted_0.txt │ ├── cls-bug2.core_opt_after_splitted_1.txt │ ├── cls-bug2.core_opt_after_splitted_2.txt │ ├── cls-bug2.core_opt_after_tre.txt │ ├── cls-bug2.free_set_closure.txt │ ├── cls-bug2.freg.txt │ ├── cls-bug2.knf.txt │ ├── cls-bug2.knf_after_inline_0.txt │ ├── cls-bug2.knf_after_inline_1.txt │ ├── cls-bug2.knf_after_inline_2.txt │ ├── cls-bug2.knf_after_licm_0.txt │ ├── cls-bug2.knf_after_licm_1.txt │ ├── cls-bug2.knf_after_licm_2.txt │ ├── cls-bug2.knf_after_lifting.txt │ ├── cls-bug2.knf_after_unbox.txt │ ├── cls-bug2.knf_to_core.txt │ ├── cls-bug2.log │ ├── cls-bug2.mbt │ ├── cls-bug2.mcore.txt │ ├── cls-bug2.resolved.txt │ ├── cls-bug2.typer.txt │ ├── cls-bug2.typer_simplified.txt │ ├── cls-bug2.xreg.txt │ ├── cls-rec-bug.core_opt2_after_fo.txt │ ├── cls-rec-bug.core_opt2_after_jtbl.txt │ ├── cls-rec-bug.core_opt2_after_lvn.txt │ ├── cls-rec-bug.core_opt_after_dfe.txt │ ├── cls-rec-bug.core_opt_after_dfe_0.txt │ ├── cls-rec-bug.core_opt_after_dfe_1.txt │ ├── cls-rec-bug.core_opt_after_dfe_2.txt │ ├── cls-rec-bug.core_opt_after_inline.txt │ ├── cls-rec-bug.core_opt_after_inline_0.txt │ ├── cls-rec-bug.core_opt_after_inline_1.txt │ ├── cls-rec-bug.core_opt_after_inline_2.txt │ ├── cls-rec-bug.core_opt_after_licm.txt │ ├── cls-rec-bug.core_opt_after_lvn.txt │ ├── cls-rec-bug.core_opt_after_o2f.txt │ ├── cls-rec-bug.core_opt_after_splitted.txt │ ├── cls-rec-bug.core_opt_after_splitted_0.txt │ ├── cls-rec-bug.core_opt_after_splitted_1.txt │ ├── cls-rec-bug.core_opt_after_splitted_2.txt │ ├── cls-rec-bug.core_opt_after_tre.txt │ ├── cls-rec-bug.free_set_closure.txt │ ├── cls-rec-bug.freg.txt │ ├── cls-rec-bug.knf.txt │ ├── cls-rec-bug.knf_after_inline_0.txt │ ├── cls-rec-bug.knf_after_inline_1.txt │ ├── cls-rec-bug.knf_after_inline_2.txt │ ├── cls-rec-bug.knf_after_licm_0.txt │ ├── cls-rec-bug.knf_after_licm_1.txt │ ├── cls-rec-bug.knf_after_licm_2.txt │ ├── cls-rec-bug.knf_after_lifting.txt │ ├── cls-rec-bug.knf_after_unbox.txt │ ├── cls-rec-bug.knf_to_core.txt │ ├── cls-rec-bug.log │ ├── cls-rec-bug.mbt │ ├── cls-rec-bug.mcore.txt │ ├── cls-rec-bug.resolved.txt │ ├── cls-rec-bug.typer.txt │ ├── cls-rec-bug.typer_simplified.txt │ ├── cls-rec-bug.xreg.txt │ ├── cls-rec.ans │ ├── cls-rec.core_opt2_after_fo.txt │ ├── cls-rec.core_opt2_after_jtbl.txt │ ├── cls-rec.core_opt2_after_lvn.txt │ ├── cls-rec.core_opt_after_dfe_0.txt │ ├── cls-rec.core_opt_after_dfe_1.txt │ ├── cls-rec.core_opt_after_dfe_2.txt │ ├── cls-rec.core_opt_after_inline_0.txt │ ├── cls-rec.core_opt_after_inline_1.txt │ ├── cls-rec.core_opt_after_inline_2.txt │ ├── cls-rec.core_opt_after_licm.txt │ ├── cls-rec.core_opt_after_lvn.txt │ ├── cls-rec.core_opt_after_o2f.txt │ ├── cls-rec.core_opt_after_splitted_0.txt │ ├── cls-rec.core_opt_after_splitted_1.txt │ ├── cls-rec.core_opt_after_splitted_2.txt │ ├── cls-rec.core_opt_after_tre.txt │ ├── cls-rec.free_set_closure.txt │ ├── cls-rec.freg.txt │ ├── cls-rec.knf.txt │ ├── cls-rec.knf_after_inline_0.txt │ ├── cls-rec.knf_after_inline_1.txt │ ├── cls-rec.knf_after_inline_2.txt │ ├── cls-rec.knf_after_licm_0.txt │ ├── cls-rec.knf_after_licm_1.txt │ ├── cls-rec.knf_after_licm_2.txt │ ├── cls-rec.knf_after_lifting.txt │ ├── cls-rec.knf_after_unbox.txt │ ├── cls-rec.knf_to_core.txt │ ├── cls-rec.log │ ├── cls-rec.mbt │ ├── cls-rec.mcore.txt │ ├── cls-rec.resolved.txt │ ├── cls-rec.typer.txt │ ├── cls-rec.typer_simplified.txt │ ├── cls-rec.xreg.txt │ ├── cls-reg-bug.ans │ ├── cls-reg-bug.core_opt2_after_fo.txt │ ├── cls-reg-bug.core_opt2_after_jtbl.txt │ ├── cls-reg-bug.core_opt2_after_lvn.txt │ ├── cls-reg-bug.core_opt_after_dfe_0.txt │ ├── cls-reg-bug.core_opt_after_dfe_1.txt │ ├── cls-reg-bug.core_opt_after_dfe_2.txt │ ├── cls-reg-bug.core_opt_after_inline_0.txt │ ├── cls-reg-bug.core_opt_after_inline_1.txt │ ├── cls-reg-bug.core_opt_after_inline_2.txt │ ├── cls-reg-bug.core_opt_after_licm.txt │ ├── cls-reg-bug.core_opt_after_lvn.txt │ ├── cls-reg-bug.core_opt_after_o2f.txt │ ├── cls-reg-bug.core_opt_after_splitted_0.txt │ ├── cls-reg-bug.core_opt_after_splitted_1.txt │ ├── cls-reg-bug.core_opt_after_splitted_2.txt │ ├── cls-reg-bug.core_opt_after_tre.txt │ ├── cls-reg-bug.free_set_closure.txt │ ├── cls-reg-bug.freg.txt │ ├── cls-reg-bug.knf.txt │ ├── cls-reg-bug.knf_after_inline_0.txt │ ├── cls-reg-bug.knf_after_inline_1.txt │ ├── cls-reg-bug.knf_after_inline_2.txt │ ├── cls-reg-bug.knf_after_licm_0.txt │ ├── cls-reg-bug.knf_after_licm_1.txt │ ├── cls-reg-bug.knf_after_licm_2.txt │ ├── cls-reg-bug.knf_after_lifting.txt │ ├── cls-reg-bug.knf_after_unbox.txt │ ├── cls-reg-bug.knf_to_core.txt │ ├── cls-reg-bug.log │ ├── cls-reg-bug.mbt │ ├── cls-reg-bug.mcore.txt │ ├── cls-reg-bug.resolved.txt │ ├── cls-reg-bug.typer.txt │ ├── cls-reg-bug.typer_simplified.txt │ ├── cls-reg-bug.xreg.txt │ ├── critical_edge.core_opt2_after_fo.txt │ ├── critical_edge.core_opt2_after_jtbl.txt │ ├── critical_edge.core_opt2_after_lvn.txt │ ├── critical_edge.core_opt_after_dfe_0.txt │ ├── critical_edge.core_opt_after_dfe_1.txt │ ├── critical_edge.core_opt_after_dfe_2.txt │ ├── critical_edge.core_opt_after_inline_0.txt │ ├── critical_edge.core_opt_after_inline_1.txt │ ├── critical_edge.core_opt_after_inline_2.txt │ ├── critical_edge.core_opt_after_licm.txt │ ├── critical_edge.core_opt_after_lvn.txt │ ├── critical_edge.core_opt_after_o2f.txt │ ├── critical_edge.core_opt_after_splitted_0.txt │ ├── critical_edge.core_opt_after_splitted_1.txt │ ├── critical_edge.core_opt_after_splitted_2.txt │ ├── critical_edge.core_opt_after_tre.txt │ ├── critical_edge.free_set_closure.txt │ ├── critical_edge.freg.txt │ ├── critical_edge.knf.txt │ ├── critical_edge.knf_after_inline_0.txt │ ├── critical_edge.knf_after_inline_1.txt │ ├── critical_edge.knf_after_inline_2.txt │ ├── critical_edge.knf_after_licm_0.txt │ ├── critical_edge.knf_after_licm_1.txt │ ├── critical_edge.knf_after_licm_2.txt │ ├── critical_edge.knf_after_lifting.txt │ ├── critical_edge.knf_after_unbox.txt │ ├── critical_edge.knf_to_core.txt │ ├── critical_edge.log │ ├── critical_edge.mbt │ ├── critical_edge.mcore.txt │ ├── critical_edge.resolved.txt │ ├── critical_edge.typer.txt │ ├── critical_edge.typer_simplified.txt │ ├── critical_edge.xreg.txt │ ├── debug.core_opt2_after_fo.txt │ ├── debug.core_opt2_after_jtbl.txt │ ├── debug.core_opt2_after_lvn.txt │ ├── debug.core_opt_after_dfe_0.txt │ ├── debug.core_opt_after_dfe_1.txt │ ├── debug.core_opt_after_dfe_2.txt │ ├── debug.core_opt_after_inline_0.txt │ ├── debug.core_opt_after_inline_1.txt │ ├── debug.core_opt_after_inline_2.txt │ ├── debug.core_opt_after_licm.txt │ ├── debug.core_opt_after_lvn.txt │ ├── debug.core_opt_after_o2f.txt │ ├── debug.core_opt_after_splitted_0.txt │ ├── debug.core_opt_after_splitted_1.txt │ ├── debug.core_opt_after_splitted_2.txt │ ├── debug.core_opt_after_tre.txt │ ├── debug.free_set_closure.txt │ ├── debug.freg.txt │ ├── debug.knf.txt │ ├── debug.knf_after_inline_0.txt │ ├── debug.knf_after_inline_1.txt │ ├── debug.knf_after_inline_2.txt │ ├── debug.knf_after_licm_0.txt │ ├── debug.knf_after_licm_1.txt │ ├── debug.knf_after_licm_2.txt │ ├── debug.knf_after_lifting.txt │ ├── debug.knf_after_unbox.txt │ ├── debug.knf_to_core.txt │ ├── debug.log │ ├── debug.mbt │ ├── debug.mcore.txt │ ├── debug.resolved.txt │ ├── debug.typer.txt │ ├── debug.typer_simplified.txt │ ├── debug.xreg.txt │ ├── even-odd.ans │ ├── even-odd.core_opt2_after_fo.txt │ ├── even-odd.core_opt2_after_jtbl.txt │ ├── even-odd.core_opt2_after_lvn.txt │ ├── even-odd.core_opt_after_dfe_0.txt │ ├── even-odd.core_opt_after_dfe_1.txt │ ├── even-odd.core_opt_after_dfe_2.txt │ ├── even-odd.core_opt_after_inline_0.txt │ ├── even-odd.core_opt_after_inline_1.txt │ ├── even-odd.core_opt_after_inline_2.txt │ ├── even-odd.core_opt_after_licm.txt │ ├── even-odd.core_opt_after_lvn.txt │ ├── even-odd.core_opt_after_o2f.txt │ ├── even-odd.core_opt_after_splitted_0.txt │ ├── even-odd.core_opt_after_splitted_1.txt │ ├── even-odd.core_opt_after_splitted_2.txt │ ├── even-odd.core_opt_after_tre.txt │ ├── even-odd.free_set_closure.txt │ ├── even-odd.freg.txt │ ├── even-odd.knf.txt │ ├── even-odd.knf_after_inline_0.txt │ ├── even-odd.knf_after_inline_1.txt │ ├── even-odd.knf_after_inline_2.txt │ ├── even-odd.knf_after_licm_0.txt │ ├── even-odd.knf_after_licm_1.txt │ ├── even-odd.knf_after_licm_2.txt │ ├── even-odd.knf_after_lifting.txt │ ├── even-odd.knf_after_unbox.txt │ ├── even-odd.knf_to_core.txt │ ├── even-odd.log │ ├── even-odd.mbt │ ├── even-odd.mcore.txt │ ├── even-odd.resolved.txt │ ├── even-odd.typer.txt │ ├── even-odd.typer_simplified.txt │ ├── even-odd.xreg.txt │ ├── feature_test.core_opt2_after_fo.txt │ ├── feature_test.core_opt2_after_jtbl.txt │ ├── feature_test.core_opt2_after_lvn.txt │ ├── feature_test.core_opt_after_dfe_0.txt │ ├── feature_test.core_opt_after_dfe_1.txt │ ├── feature_test.core_opt_after_dfe_2.txt │ ├── feature_test.core_opt_after_inline_0.txt │ ├── feature_test.core_opt_after_inline_1.txt │ ├── feature_test.core_opt_after_inline_2.txt │ ├── feature_test.core_opt_after_licm.txt │ ├── feature_test.core_opt_after_lvn.txt │ ├── feature_test.core_opt_after_o2f.txt │ ├── feature_test.core_opt_after_splitted_0.txt │ ├── feature_test.core_opt_after_splitted_1.txt │ ├── feature_test.core_opt_after_splitted_2.txt │ ├── feature_test.core_opt_after_tre.txt │ ├── feature_test.free_set_closure.txt │ ├── feature_test.freg.txt │ ├── feature_test.knf.txt │ ├── feature_test.knf_after_inline_0.txt │ ├── feature_test.knf_after_inline_1.txt │ ├── feature_test.knf_after_inline_2.txt │ ├── feature_test.knf_after_licm_0.txt │ ├── feature_test.knf_after_licm_1.txt │ ├── feature_test.knf_after_licm_2.txt │ ├── feature_test.knf_after_lifting.txt │ ├── feature_test.knf_after_unbox.txt │ ├── feature_test.knf_to_core.txt │ ├── feature_test.log │ ├── feature_test.mbt │ ├── feature_test.mcore.txt │ ├── feature_test.resolved.txt │ ├── feature_test.typer.txt │ ├── feature_test.typer_simplified.txt │ ├── feature_test.xreg.txt │ ├── fib.ans │ ├── fib.core_opt2_after_fo.txt │ ├── fib.core_opt2_after_jtbl.txt │ ├── fib.core_opt2_after_lvn.txt │ ├── fib.core_opt_after_dfe_0.txt │ ├── fib.core_opt_after_dfe_1.txt │ ├── fib.core_opt_after_dfe_2.txt │ ├── fib.core_opt_after_inline_0.txt │ ├── fib.core_opt_after_inline_1.txt │ ├── fib.core_opt_after_inline_2.txt │ ├── fib.core_opt_after_licm.txt │ ├── fib.core_opt_after_lvn.txt │ ├── fib.core_opt_after_o2f.txt │ ├── fib.core_opt_after_splitted_0.txt │ ├── fib.core_opt_after_splitted_1.txt │ ├── fib.core_opt_after_splitted_2.txt │ ├── fib.core_opt_after_tre.txt │ ├── fib.free_set_closure.txt │ ├── fib.freg.txt │ ├── fib.knf.txt │ ├── fib.knf_after_inline_0.txt │ ├── fib.knf_after_inline_1.txt │ ├── fib.knf_after_inline_2.txt │ ├── fib.knf_after_licm_0.txt │ ├── fib.knf_after_licm_1.txt │ ├── fib.knf_after_licm_2.txt │ ├── fib.knf_after_lifting.txt │ ├── fib.knf_after_unbox.txt │ ├── fib.knf_to_core.txt │ ├── fib.log │ ├── fib.mbt │ ├── fib.mcore.txt │ ├── fib.resolved.txt │ ├── fib.typer.txt │ ├── fib.typer_simplified.txt │ ├── fib.xreg.txt │ ├── float.ans │ ├── float.core_opt2_after_fo.txt │ ├── float.core_opt2_after_jtbl.txt │ ├── float.core_opt2_after_lvn.txt │ ├── float.core_opt_after_dfe_0.txt │ ├── float.core_opt_after_dfe_1.txt │ ├── float.core_opt_after_dfe_2.txt │ ├── float.core_opt_after_inline_0.txt │ ├── float.core_opt_after_inline_1.txt │ ├── float.core_opt_after_inline_2.txt │ ├── float.core_opt_after_licm.txt │ ├── float.core_opt_after_lvn.txt │ ├── float.core_opt_after_o2f.txt │ ├── float.core_opt_after_splitted_0.txt │ ├── float.core_opt_after_splitted_1.txt │ ├── float.core_opt_after_splitted_2.txt │ ├── float.core_opt_after_tre.txt │ ├── float.free_set_closure.txt │ ├── float.freg.txt │ ├── float.knf.txt │ ├── float.knf_after_inline_0.txt │ ├── float.knf_after_inline_1.txt │ ├── float.knf_after_inline_2.txt │ ├── float.knf_after_licm_0.txt │ ├── float.knf_after_licm_1.txt │ ├── float.knf_after_licm_2.txt │ ├── float.knf_after_lifting.txt │ ├── float.knf_after_unbox.txt │ ├── float.knf_to_core.txt │ ├── float.log │ ├── float.mbt │ ├── float.mcore.txt │ ├── float.resolved.txt │ ├── float.typer.txt │ ├── float.typer_simplified.txt │ ├── float.xreg.txt │ ├── funcomp.ans │ ├── funcomp.core_opt2_after_fo.txt │ ├── funcomp.core_opt2_after_jtbl.txt │ ├── funcomp.core_opt2_after_lvn.txt │ ├── funcomp.core_opt_after_dfe_0.txt │ ├── funcomp.core_opt_after_dfe_1.txt │ ├── funcomp.core_opt_after_dfe_2.txt │ ├── funcomp.core_opt_after_inline_0.txt │ ├── funcomp.core_opt_after_inline_1.txt │ ├── funcomp.core_opt_after_inline_2.txt │ ├── funcomp.core_opt_after_licm.txt │ ├── funcomp.core_opt_after_lvn.txt │ ├── funcomp.core_opt_after_o2f.txt │ ├── funcomp.core_opt_after_splitted_0.txt │ ├── funcomp.core_opt_after_splitted_1.txt │ ├── funcomp.core_opt_after_splitted_2.txt │ ├── funcomp.core_opt_after_tre.txt │ ├── funcomp.free_set_closure.txt │ ├── funcomp.freg.txt │ ├── funcomp.knf.txt │ ├── funcomp.knf_after_inline_0.txt │ ├── funcomp.knf_after_inline_1.txt │ ├── funcomp.knf_after_inline_2.txt │ ├── funcomp.knf_after_licm_0.txt │ ├── funcomp.knf_after_licm_1.txt │ ├── funcomp.knf_after_licm_2.txt │ ├── funcomp.knf_after_lifting.txt │ ├── funcomp.knf_after_unbox.txt │ ├── funcomp.knf_to_core.txt │ ├── funcomp.log │ ├── funcomp.mbt │ ├── funcomp.mcore.txt │ ├── funcomp.resolved.txt │ ├── funcomp.typer.txt │ ├── funcomp.typer_simplified.txt │ ├── funcomp.xreg.txt │ ├── gcd.ans │ ├── gcd.core_opt2_after_fo.txt │ ├── gcd.core_opt2_after_jtbl.txt │ ├── gcd.core_opt2_after_lvn.txt │ ├── gcd.core_opt_after_dfe_0.txt │ ├── gcd.core_opt_after_dfe_1.txt │ ├── gcd.core_opt_after_dfe_2.txt │ ├── gcd.core_opt_after_inline_0.txt │ ├── gcd.core_opt_after_inline_1.txt │ ├── gcd.core_opt_after_inline_2.txt │ ├── gcd.core_opt_after_licm.txt │ ├── gcd.core_opt_after_lvn.txt │ ├── gcd.core_opt_after_o2f.txt │ ├── gcd.core_opt_after_splitted_0.txt │ ├── gcd.core_opt_after_splitted_1.txt │ ├── gcd.core_opt_after_splitted_2.txt │ ├── gcd.core_opt_after_tre.txt │ ├── gcd.free_set_closure.txt │ ├── gcd.freg.txt │ ├── gcd.knf.txt │ ├── gcd.knf_after_inline_0.txt │ ├── gcd.knf_after_inline_1.txt │ ├── gcd.knf_after_inline_2.txt │ ├── gcd.knf_after_licm_0.txt │ ├── gcd.knf_after_licm_1.txt │ ├── gcd.knf_after_licm_2.txt │ ├── gcd.knf_after_lifting.txt │ ├── gcd.knf_after_unbox.txt │ ├── gcd.knf_to_core.txt │ ├── gcd.log │ ├── gcd.mbt │ ├── gcd.mcore.txt │ ├── gcd.resolved.txt │ ├── gcd.typer.txt │ ├── gcd.typer_simplified.txt │ ├── gcd.xreg.txt │ ├── global_spill.core_opt2_after_fo.txt │ ├── global_spill.core_opt2_after_jtbl.txt │ ├── global_spill.core_opt2_after_lvn.txt │ ├── global_spill.core_opt_after_dfe_0.txt │ ├── global_spill.core_opt_after_dfe_1.txt │ ├── global_spill.core_opt_after_dfe_2.txt │ ├── global_spill.core_opt_after_inline_0.txt │ ├── global_spill.core_opt_after_inline_1.txt │ ├── global_spill.core_opt_after_inline_2.txt │ ├── global_spill.core_opt_after_licm.txt │ ├── global_spill.core_opt_after_lvn.txt │ ├── global_spill.core_opt_after_o2f.txt │ ├── global_spill.core_opt_after_splitted_0.txt │ ├── global_spill.core_opt_after_splitted_1.txt │ ├── global_spill.core_opt_after_splitted_2.txt │ ├── global_spill.core_opt_after_tre.txt │ ├── global_spill.free_set_closure.txt │ ├── global_spill.freg.txt │ ├── global_spill.knf.txt │ ├── global_spill.knf_after_inline_0.txt │ ├── global_spill.knf_after_inline_1.txt │ ├── global_spill.knf_after_inline_2.txt │ ├── global_spill.knf_after_licm_0.txt │ ├── global_spill.knf_after_licm_1.txt │ ├── global_spill.knf_after_licm_2.txt │ ├── global_spill.knf_after_lifting.txt │ ├── global_spill.knf_after_unbox.txt │ ├── global_spill.knf_to_core.txt │ ├── global_spill.log │ ├── global_spill.mbt │ ├── global_spill.mcore.txt │ ├── global_spill.resolved.txt │ ├── global_spill.typer.txt │ ├── global_spill.typer_simplified.txt │ ├── global_spill.xreg.txt │ ├── htuple.core_opt2_after_fo.txt │ ├── htuple.core_opt2_after_jtbl.txt │ ├── htuple.core_opt2_after_lvn.txt │ ├── htuple.core_opt_after_dfe_0.txt │ ├── htuple.core_opt_after_dfe_1.txt │ ├── htuple.core_opt_after_dfe_2.txt │ ├── htuple.core_opt_after_inline_0.txt │ ├── htuple.core_opt_after_inline_1.txt │ ├── htuple.core_opt_after_inline_2.txt │ ├── htuple.core_opt_after_licm.txt │ ├── htuple.core_opt_after_lvn.txt │ ├── htuple.core_opt_after_o2f.txt │ ├── htuple.core_opt_after_splitted_0.txt │ ├── htuple.core_opt_after_splitted_1.txt │ ├── htuple.core_opt_after_splitted_2.txt │ ├── htuple.core_opt_after_tre.txt │ ├── htuple.free_set_closure.txt │ ├── htuple.freg.txt │ ├── htuple.knf.txt │ ├── htuple.knf_after_inline_0.txt │ ├── htuple.knf_after_inline_1.txt │ ├── htuple.knf_after_inline_2.txt │ ├── htuple.knf_after_licm_0.txt │ ├── htuple.knf_after_licm_1.txt │ ├── htuple.knf_after_licm_2.txt │ ├── htuple.knf_after_lifting.txt │ ├── htuple.knf_after_unbox.txt │ ├── htuple.knf_to_core.txt │ ├── htuple.log │ ├── htuple.mbt │ ├── htuple.mcore.txt │ ├── htuple.resolved.txt │ ├── htuple.typer.txt │ ├── htuple.typer_simplified.txt │ ├── htuple.xreg.txt │ ├── id.ans │ ├── id.core_opt2_after_fo.txt │ ├── id.core_opt2_after_jtbl.txt │ ├── id.core_opt2_after_lvn.txt │ ├── id.core_opt_after_dfe_0.txt │ ├── id.core_opt_after_dfe_1.txt │ ├── id.core_opt_after_dfe_2.txt │ ├── id.core_opt_after_inline_0.txt │ ├── id.core_opt_after_inline_1.txt │ ├── id.core_opt_after_inline_2.txt │ ├── id.core_opt_after_licm.txt │ ├── id.core_opt_after_lvn.txt │ ├── id.core_opt_after_o2f.txt │ ├── id.core_opt_after_splitted_0.txt │ ├── id.core_opt_after_splitted_1.txt │ ├── id.core_opt_after_splitted_2.txt │ ├── id.core_opt_after_tre.txt │ ├── id.free_set_closure.txt │ ├── id.freg.txt │ ├── id.knf.txt │ ├── id.knf_after_inline_0.txt │ ├── id.knf_after_inline_1.txt │ ├── id.knf_after_inline_2.txt │ ├── id.knf_after_licm_0.txt │ ├── id.knf_after_licm_1.txt │ ├── id.knf_after_licm_2.txt │ ├── id.knf_after_lifting.txt │ ├── id.knf_after_unbox.txt │ ├── id.knf_to_core.txt │ ├── id.log │ ├── id.mbt │ ├── id.mcore.txt │ ├── id.resolved.txt │ ├── id.typer.txt │ ├── id.typer_simplified.txt │ ├── id.xreg.txt │ ├── inprod-loop.ans │ ├── inprod-loop.core_opt2_after_fo.txt │ ├── inprod-loop.core_opt2_after_jtbl.txt │ ├── inprod-loop.core_opt2_after_lvn.txt │ ├── inprod-loop.core_opt_after_dfe_0.txt │ ├── inprod-loop.core_opt_after_dfe_1.txt │ ├── inprod-loop.core_opt_after_dfe_2.txt │ ├── inprod-loop.core_opt_after_inline_0.txt │ ├── inprod-loop.core_opt_after_inline_1.txt │ ├── inprod-loop.core_opt_after_inline_2.txt │ ├── inprod-loop.core_opt_after_licm.txt │ ├── inprod-loop.core_opt_after_lvn.txt │ ├── inprod-loop.core_opt_after_o2f.txt │ ├── inprod-loop.core_opt_after_splitted_0.txt │ ├── inprod-loop.core_opt_after_splitted_1.txt │ ├── inprod-loop.core_opt_after_splitted_2.txt │ ├── inprod-loop.core_opt_after_tre.txt │ ├── inprod-loop.free_set_closure.txt │ ├── inprod-loop.freg.txt │ ├── inprod-loop.knf.txt │ ├── inprod-loop.knf_after_inline_0.txt │ ├── inprod-loop.knf_after_inline_1.txt │ ├── inprod-loop.knf_after_inline_2.txt │ ├── inprod-loop.knf_after_licm_0.txt │ ├── inprod-loop.knf_after_licm_1.txt │ ├── inprod-loop.knf_after_licm_2.txt │ ├── inprod-loop.knf_after_lifting.txt │ ├── inprod-loop.knf_after_unbox.txt │ ├── inprod-loop.knf_to_core.txt │ ├── inprod-loop.log │ ├── inprod-loop.mbt │ ├── inprod-loop.mcore.txt │ ├── inprod-loop.resolved.txt │ ├── inprod-loop.typer.txt │ ├── inprod-loop.typer_simplified.txt │ ├── inprod-loop.xreg.txt │ ├── inprod-rec.ans │ ├── inprod-rec.core_opt2_after_fo.txt │ ├── inprod-rec.core_opt2_after_jtbl.txt │ ├── inprod-rec.core_opt2_after_lvn.txt │ ├── inprod-rec.core_opt_after_dfe_0.txt │ ├── inprod-rec.core_opt_after_dfe_1.txt │ ├── inprod-rec.core_opt_after_dfe_2.txt │ ├── inprod-rec.core_opt_after_inline_0.txt │ ├── inprod-rec.core_opt_after_inline_1.txt │ ├── inprod-rec.core_opt_after_inline_2.txt │ ├── inprod-rec.core_opt_after_licm.txt │ ├── inprod-rec.core_opt_after_lvn.txt │ ├── inprod-rec.core_opt_after_o2f.txt │ ├── inprod-rec.core_opt_after_splitted_0.txt │ ├── inprod-rec.core_opt_after_splitted_1.txt │ ├── inprod-rec.core_opt_after_splitted_2.txt │ ├── inprod-rec.core_opt_after_tre.txt │ ├── inprod-rec.free_set_closure.txt │ ├── inprod-rec.freg.txt │ ├── inprod-rec.knf.txt │ ├── inprod-rec.knf_after_inline_0.txt │ ├── inprod-rec.knf_after_inline_1.txt │ ├── inprod-rec.knf_after_inline_2.txt │ ├── inprod-rec.knf_after_licm_0.txt │ ├── inprod-rec.knf_after_licm_1.txt │ ├── inprod-rec.knf_after_licm_2.txt │ ├── inprod-rec.knf_after_lifting.txt │ ├── inprod-rec.knf_after_unbox.txt │ ├── inprod-rec.knf_to_core.txt │ ├── inprod-rec.log │ ├── inprod-rec.mbt │ ├── inprod-rec.mcore.txt │ ├── inprod-rec.resolved.txt │ ├── inprod-rec.typer.txt │ ├── inprod-rec.typer_simplified.txt │ ├── inprod-rec.xreg.txt │ ├── inprod.ans │ ├── inprod.core_opt2_after_fo.txt │ ├── inprod.core_opt2_after_jtbl.txt │ ├── inprod.core_opt2_after_lvn.txt │ ├── inprod.core_opt_after_dfe_0.txt │ ├── inprod.core_opt_after_dfe_1.txt │ ├── inprod.core_opt_after_dfe_2.txt │ ├── inprod.core_opt_after_inline_0.txt │ ├── inprod.core_opt_after_inline_1.txt │ ├── inprod.core_opt_after_inline_2.txt │ ├── inprod.core_opt_after_licm.txt │ ├── inprod.core_opt_after_lvn.txt │ ├── inprod.core_opt_after_o2f.txt │ ├── inprod.core_opt_after_splitted_0.txt │ ├── inprod.core_opt_after_splitted_1.txt │ ├── inprod.core_opt_after_splitted_2.txt │ ├── inprod.core_opt_after_tre.txt │ ├── inprod.free_set_closure.txt │ ├── inprod.freg.txt │ ├── inprod.knf.txt │ ├── inprod.knf_after_inline_0.txt │ ├── inprod.knf_after_inline_1.txt │ ├── inprod.knf_after_inline_2.txt │ ├── inprod.knf_after_licm_0.txt │ ├── inprod.knf_after_licm_1.txt │ ├── inprod.knf_after_licm_2.txt │ ├── inprod.knf_after_lifting.txt │ ├── inprod.knf_after_unbox.txt │ ├── inprod.knf_to_core.txt │ ├── inprod.log │ ├── inprod.mbt │ ├── inprod.mcore.txt │ ├── inprod.resolved.txt │ ├── inprod.typer.txt │ ├── inprod.typer_simplified.txt │ ├── inprod.xreg.txt │ ├── int_min.core_opt2_after_fo.txt │ ├── int_min.core_opt2_after_jtbl.txt │ ├── int_min.core_opt2_after_lvn.txt │ ├── int_min.core_opt_after_dfe_0.txt │ ├── int_min.core_opt_after_dfe_1.txt │ ├── int_min.core_opt_after_dfe_2.txt │ ├── int_min.core_opt_after_inline_0.txt │ ├── int_min.core_opt_after_inline_1.txt │ ├── int_min.core_opt_after_inline_2.txt │ ├── int_min.core_opt_after_licm.txt │ ├── int_min.core_opt_after_lvn.txt │ ├── int_min.core_opt_after_o2f.txt │ ├── int_min.core_opt_after_splitted_0.txt │ ├── int_min.core_opt_after_splitted_1.txt │ ├── int_min.core_opt_after_splitted_2.txt │ ├── int_min.core_opt_after_tre.txt │ ├── int_min.free_set_closure.txt │ ├── int_min.freg.txt │ ├── int_min.knf.txt │ ├── int_min.knf_after_inline_0.txt │ ├── int_min.knf_after_inline_1.txt │ ├── int_min.knf_after_inline_2.txt │ ├── int_min.knf_after_licm_0.txt │ ├── int_min.knf_after_licm_1.txt │ ├── int_min.knf_after_licm_2.txt │ ├── int_min.knf_after_lifting.txt │ ├── int_min.knf_after_unbox.txt │ ├── int_min.knf_to_core.txt │ ├── int_min.log │ ├── int_min.mbt │ ├── int_min.mcore.txt │ ├── int_min.resolved.txt │ ├── int_min.typer.txt │ ├── int_min.typer_simplified.txt │ ├── int_min.xreg.txt │ ├── join-reg.ans │ ├── join-reg.core_opt2_after_fo.txt │ ├── join-reg.core_opt2_after_jtbl.txt │ ├── join-reg.core_opt2_after_lvn.txt │ ├── join-reg.core_opt_after_dfe_0.txt │ ├── join-reg.core_opt_after_dfe_1.txt │ ├── join-reg.core_opt_after_dfe_2.txt │ ├── join-reg.core_opt_after_inline_0.txt │ ├── join-reg.core_opt_after_inline_1.txt │ ├── join-reg.core_opt_after_inline_2.txt │ ├── join-reg.core_opt_after_licm.txt │ ├── join-reg.core_opt_after_lvn.txt │ ├── join-reg.core_opt_after_o2f.txt │ ├── join-reg.core_opt_after_splitted_0.txt │ ├── join-reg.core_opt_after_splitted_1.txt │ ├── join-reg.core_opt_after_splitted_2.txt │ ├── join-reg.core_opt_after_tre.txt │ ├── join-reg.free_set_closure.txt │ ├── join-reg.freg.txt │ ├── join-reg.knf.txt │ ├── join-reg.knf_after_inline_0.txt │ ├── join-reg.knf_after_inline_1.txt │ ├── join-reg.knf_after_inline_2.txt │ ├── join-reg.knf_after_licm_0.txt │ ├── join-reg.knf_after_licm_1.txt │ ├── join-reg.knf_after_licm_2.txt │ ├── join-reg.knf_after_lifting.txt │ ├── join-reg.knf_after_unbox.txt │ ├── join-reg.knf_to_core.txt │ ├── join-reg.log │ ├── join-reg.mbt │ ├── join-reg.mcore.txt │ ├── join-reg.resolved.txt │ ├── join-reg.typer.txt │ ├── join-reg.typer_simplified.txt │ ├── join-reg.xreg.txt │ ├── join-reg2.ans │ ├── join-reg2.core_opt2_after_fo.txt │ ├── join-reg2.core_opt2_after_jtbl.txt │ ├── join-reg2.core_opt2_after_lvn.txt │ ├── join-reg2.core_opt_after_dfe_0.txt │ ├── join-reg2.core_opt_after_dfe_1.txt │ ├── join-reg2.core_opt_after_dfe_2.txt │ ├── join-reg2.core_opt_after_inline_0.txt │ ├── join-reg2.core_opt_after_inline_1.txt │ ├── join-reg2.core_opt_after_inline_2.txt │ ├── join-reg2.core_opt_after_licm.txt │ ├── join-reg2.core_opt_after_lvn.txt │ ├── join-reg2.core_opt_after_o2f.txt │ ├── join-reg2.core_opt_after_splitted_0.txt │ ├── join-reg2.core_opt_after_splitted_1.txt │ ├── join-reg2.core_opt_after_splitted_2.txt │ ├── join-reg2.core_opt_after_tre.txt │ ├── join-reg2.free_set_closure.txt │ ├── join-reg2.freg.txt │ ├── join-reg2.knf.txt │ ├── join-reg2.knf_after_inline_0.txt │ ├── join-reg2.knf_after_inline_1.txt │ ├── join-reg2.knf_after_inline_2.txt │ ├── join-reg2.knf_after_licm_0.txt │ ├── join-reg2.knf_after_licm_1.txt │ ├── join-reg2.knf_after_licm_2.txt │ ├── join-reg2.knf_after_lifting.txt │ ├── join-reg2.knf_after_unbox.txt │ ├── join-reg2.knf_to_core.txt │ ├── join-reg2.log │ ├── join-reg2.mbt │ ├── join-reg2.mcore.txt │ ├── join-reg2.resolved.txt │ ├── join-reg2.typer.txt │ ├── join-reg2.typer_simplified.txt │ ├── join-reg2.xreg.txt │ ├── join-stack.ans │ ├── join-stack.core_opt2_after_fo.txt │ ├── join-stack.core_opt2_after_jtbl.txt │ ├── join-stack.core_opt2_after_lvn.txt │ ├── join-stack.core_opt_after_dfe_0.txt │ ├── join-stack.core_opt_after_dfe_1.txt │ ├── join-stack.core_opt_after_dfe_2.txt │ ├── join-stack.core_opt_after_inline_0.txt │ ├── join-stack.core_opt_after_inline_1.txt │ ├── join-stack.core_opt_after_inline_2.txt │ ├── join-stack.core_opt_after_licm.txt │ ├── join-stack.core_opt_after_lvn.txt │ ├── join-stack.core_opt_after_o2f.txt │ ├── join-stack.core_opt_after_splitted_0.txt │ ├── join-stack.core_opt_after_splitted_1.txt │ ├── join-stack.core_opt_after_splitted_2.txt │ ├── join-stack.core_opt_after_tre.txt │ ├── join-stack.free_set_closure.txt │ ├── join-stack.freg.txt │ ├── join-stack.knf.txt │ ├── join-stack.knf_after_inline_0.txt │ ├── join-stack.knf_after_inline_1.txt │ ├── join-stack.knf_after_inline_2.txt │ ├── join-stack.knf_after_licm_0.txt │ ├── join-stack.knf_after_licm_1.txt │ ├── join-stack.knf_after_licm_2.txt │ ├── join-stack.knf_after_lifting.txt │ ├── join-stack.knf_after_unbox.txt │ ├── join-stack.knf_to_core.txt │ ├── join-stack.log │ ├── join-stack.mbt │ ├── join-stack.mcore.txt │ ├── join-stack.resolved.txt │ ├── join-stack.typer.txt │ ├── join-stack.typer_simplified.txt │ ├── join-stack.xreg.txt │ ├── join-stack2.ans │ ├── join-stack2.core_opt2_after_fo.txt │ ├── join-stack2.core_opt2_after_jtbl.txt │ ├── join-stack2.core_opt2_after_lvn.txt │ ├── join-stack2.core_opt_after_dfe_0.txt │ ├── join-stack2.core_opt_after_dfe_1.txt │ ├── join-stack2.core_opt_after_dfe_2.txt │ ├── join-stack2.core_opt_after_inline_0.txt │ ├── join-stack2.core_opt_after_inline_1.txt │ ├── join-stack2.core_opt_after_inline_2.txt │ ├── join-stack2.core_opt_after_licm.txt │ ├── join-stack2.core_opt_after_lvn.txt │ ├── join-stack2.core_opt_after_o2f.txt │ ├── join-stack2.core_opt_after_splitted_0.txt │ ├── join-stack2.core_opt_after_splitted_1.txt │ ├── join-stack2.core_opt_after_splitted_2.txt │ ├── join-stack2.core_opt_after_tre.txt │ ├── join-stack2.free_set_closure.txt │ ├── join-stack2.freg.txt │ ├── join-stack2.knf.txt │ ├── join-stack2.knf_after_inline_0.txt │ ├── join-stack2.knf_after_inline_1.txt │ ├── join-stack2.knf_after_inline_2.txt │ ├── join-stack2.knf_after_licm_0.txt │ ├── join-stack2.knf_after_licm_1.txt │ ├── join-stack2.knf_after_licm_2.txt │ ├── join-stack2.knf_after_lifting.txt │ ├── join-stack2.knf_after_unbox.txt │ ├── join-stack2.knf_to_core.txt │ ├── join-stack2.log │ ├── join-stack2.mbt │ ├── join-stack2.mcore.txt │ ├── join-stack2.resolved.txt │ ├── join-stack2.typer.txt │ ├── join-stack2.typer_simplified.txt │ ├── join-stack2.xreg.txt │ ├── join-stack3.ans │ ├── join-stack3.core_opt2_after_fo.txt │ ├── join-stack3.core_opt2_after_jtbl.txt │ ├── join-stack3.core_opt2_after_lvn.txt │ ├── join-stack3.core_opt_after_dfe_0.txt │ ├── join-stack3.core_opt_after_dfe_1.txt │ ├── join-stack3.core_opt_after_dfe_2.txt │ ├── join-stack3.core_opt_after_inline_0.txt │ ├── join-stack3.core_opt_after_inline_1.txt │ ├── join-stack3.core_opt_after_inline_2.txt │ ├── join-stack3.core_opt_after_licm.txt │ ├── join-stack3.core_opt_after_lvn.txt │ ├── join-stack3.core_opt_after_o2f.txt │ ├── join-stack3.core_opt_after_splitted_0.txt │ ├── join-stack3.core_opt_after_splitted_1.txt │ ├── join-stack3.core_opt_after_splitted_2.txt │ ├── join-stack3.core_opt_after_tre.txt │ ├── join-stack3.free_set_closure.txt │ ├── join-stack3.freg.txt │ ├── join-stack3.knf.txt │ ├── join-stack3.knf_after_inline_0.txt │ ├── join-stack3.knf_after_inline_1.txt │ ├── join-stack3.knf_after_inline_2.txt │ ├── join-stack3.knf_after_licm_0.txt │ ├── join-stack3.knf_after_licm_1.txt │ ├── join-stack3.knf_after_licm_2.txt │ ├── join-stack3.knf_after_lifting.txt │ ├── join-stack3.knf_after_unbox.txt │ ├── join-stack3.knf_to_core.txt │ ├── join-stack3.log │ ├── join-stack3.mbt │ ├── join-stack3.mcore.txt │ ├── join-stack3.resolved.txt │ ├── join-stack3.typer.txt │ ├── join-stack3.typer_simplified.txt │ ├── join-stack3.xreg.txt │ ├── landins_knot.core_opt2_after_fo.txt │ ├── landins_knot.core_opt2_after_jtbl.txt │ ├── landins_knot.core_opt2_after_lvn.txt │ ├── landins_knot.core_opt_after_dfe_0.txt │ ├── landins_knot.core_opt_after_dfe_1.txt │ ├── landins_knot.core_opt_after_dfe_2.txt │ ├── landins_knot.core_opt_after_inline_0.txt │ ├── landins_knot.core_opt_after_inline_1.txt │ ├── landins_knot.core_opt_after_inline_2.txt │ ├── landins_knot.core_opt_after_licm.txt │ ├── landins_knot.core_opt_after_lvn.txt │ ├── landins_knot.core_opt_after_o2f.txt │ ├── landins_knot.core_opt_after_splitted_0.txt │ ├── landins_knot.core_opt_after_splitted_1.txt │ ├── landins_knot.core_opt_after_splitted_2.txt │ ├── landins_knot.core_opt_after_tre.txt │ ├── landins_knot.free_set_closure.txt │ ├── landins_knot.freg.txt │ ├── landins_knot.knf.txt │ ├── landins_knot.knf_after_inline_0.txt │ ├── landins_knot.knf_after_inline_1.txt │ ├── landins_knot.knf_after_inline_2.txt │ ├── landins_knot.knf_after_licm_0.txt │ ├── landins_knot.knf_after_licm_1.txt │ ├── landins_knot.knf_after_licm_2.txt │ ├── landins_knot.knf_after_lifting.txt │ ├── landins_knot.knf_after_unbox.txt │ ├── landins_knot.knf_to_core.txt │ ├── landins_knot.log │ ├── landins_knot.mbt │ ├── landins_knot.mcore.txt │ ├── landins_knot.resolved.txt │ ├── landins_knot.typer.txt │ ├── landins_knot.typer_simplified.txt │ ├── landins_knot.xreg.txt │ ├── mandelbrot.core_opt2_after_fo.txt │ ├── mandelbrot.core_opt2_after_jtbl.txt │ ├── mandelbrot.core_opt2_after_lvn.txt │ ├── mandelbrot.core_opt_after_dfe_0.txt │ ├── mandelbrot.core_opt_after_dfe_1.txt │ ├── mandelbrot.core_opt_after_dfe_2.txt │ ├── mandelbrot.core_opt_after_inline_0.txt │ ├── mandelbrot.core_opt_after_inline_1.txt │ ├── mandelbrot.core_opt_after_inline_2.txt │ ├── mandelbrot.core_opt_after_licm.txt │ ├── mandelbrot.core_opt_after_lvn.txt │ ├── mandelbrot.core_opt_after_o2f.txt │ ├── mandelbrot.core_opt_after_splitted_0.txt │ ├── mandelbrot.core_opt_after_splitted_1.txt │ ├── mandelbrot.core_opt_after_splitted_2.txt │ ├── mandelbrot.core_opt_after_tre.txt │ ├── mandelbrot.free_set_closure.txt │ ├── mandelbrot.freg.txt │ ├── mandelbrot.knf.txt │ ├── mandelbrot.knf_after_inline_0.txt │ ├── mandelbrot.knf_after_inline_1.txt │ ├── mandelbrot.knf_after_inline_2.txt │ ├── mandelbrot.knf_after_licm_0.txt │ ├── mandelbrot.knf_after_licm_1.txt │ ├── mandelbrot.knf_after_licm_2.txt │ ├── mandelbrot.knf_after_lifting.txt │ ├── mandelbrot.knf_after_unbox.txt │ ├── mandelbrot.knf_to_core.txt │ ├── mandelbrot.log │ ├── mandelbrot.mbt │ ├── mandelbrot.mcore.txt │ ├── mandelbrot.resolved.txt │ ├── mandelbrot.typer.txt │ ├── mandelbrot.typer_simplified.txt │ ├── mandelbrot.xreg.txt │ ├── manyargs.ans │ ├── match.knf.txt │ ├── match.log │ ├── match.mbt │ ├── match.resolved.txt │ ├── match.typer.txt │ ├── match.typer_simplified.txt │ ├── match2.knf.txt │ ├── match2.log │ ├── match2.mbt │ ├── match2.resolved.txt │ ├── match2.typer.txt │ ├── match2.typer_simplified.txt │ ├── matmul-flat.ans │ ├── matmul-flat.core_opt2_after_fo.txt │ ├── matmul-flat.core_opt2_after_jtbl.txt │ ├── matmul-flat.core_opt2_after_lvn.txt │ ├── matmul-flat.core_opt_after_dfe_0.txt │ ├── matmul-flat.core_opt_after_dfe_1.txt │ ├── matmul-flat.core_opt_after_dfe_2.txt │ ├── matmul-flat.core_opt_after_inline_0.txt │ ├── matmul-flat.core_opt_after_inline_1.txt │ ├── matmul-flat.core_opt_after_inline_2.txt │ ├── matmul-flat.core_opt_after_licm.txt │ ├── matmul-flat.core_opt_after_lvn.txt │ ├── matmul-flat.core_opt_after_o2f.txt │ ├── matmul-flat.core_opt_after_splitted_0.txt │ ├── matmul-flat.core_opt_after_splitted_1.txt │ ├── matmul-flat.core_opt_after_splitted_2.txt │ ├── matmul-flat.core_opt_after_tre.txt │ ├── matmul-flat.free_set_closure.txt │ ├── matmul-flat.freg.txt │ ├── matmul-flat.knf.txt │ ├── matmul-flat.knf_after_inline_0.txt │ ├── matmul-flat.knf_after_inline_1.txt │ ├── matmul-flat.knf_after_inline_2.txt │ ├── matmul-flat.knf_after_licm_0.txt │ ├── matmul-flat.knf_after_licm_1.txt │ ├── matmul-flat.knf_after_licm_2.txt │ ├── matmul-flat.knf_after_lifting.txt │ ├── matmul-flat.knf_after_unbox.txt │ ├── matmul-flat.knf_to_core.txt │ ├── matmul-flat.log │ ├── matmul-flat.mbt │ ├── matmul-flat.mcore.txt │ ├── matmul-flat.resolved.txt │ ├── matmul-flat.typer.txt │ ├── matmul-flat.typer_simplified.txt │ ├── matmul-flat.xreg.txt │ ├── matmul.ans │ ├── matmul.core_opt2_after_fo.txt │ ├── matmul.core_opt2_after_jtbl.txt │ ├── matmul.core_opt2_after_lvn.txt │ ├── matmul.core_opt_after_dfe_0.txt │ ├── matmul.core_opt_after_dfe_1.txt │ ├── matmul.core_opt_after_dfe_2.txt │ ├── matmul.core_opt_after_inline_0.txt │ ├── matmul.core_opt_after_inline_1.txt │ ├── matmul.core_opt_after_inline_2.txt │ ├── matmul.core_opt_after_licm.txt │ ├── matmul.core_opt_after_lvn.txt │ ├── matmul.core_opt_after_o2f.txt │ ├── matmul.core_opt_after_splitted_0.txt │ ├── matmul.core_opt_after_splitted_1.txt │ ├── matmul.core_opt_after_splitted_2.txt │ ├── matmul.core_opt_after_tre.txt │ ├── matmul.free_set_closure.txt │ ├── matmul.freg.txt │ ├── matmul.knf.txt │ ├── matmul.knf_after_inline_0.txt │ ├── matmul.knf_after_inline_1.txt │ ├── matmul.knf_after_inline_2.txt │ ├── matmul.knf_after_licm_0.txt │ ├── matmul.knf_after_licm_1.txt │ ├── matmul.knf_after_licm_2.txt │ ├── matmul.knf_after_lifting.txt │ ├── matmul.knf_after_unbox.txt │ ├── matmul.knf_to_core.txt │ ├── matmul.log │ ├── matmul.mbt │ ├── matmul.mcore.txt │ ├── matmul.resolved.txt │ ├── matmul.typer.txt │ ├── matmul.typer_simplified.txt │ ├── matmul.xreg.txt │ ├── min.core_opt2_after_fo.txt │ ├── min.core_opt2_after_jtbl.txt │ ├── min.core_opt2_after_lvn.txt │ ├── min.core_opt_after_dfe_0.txt │ ├── min.core_opt_after_dfe_1.txt │ ├── min.core_opt_after_dfe_2.txt │ ├── min.core_opt_after_inline_0.txt │ ├── min.core_opt_after_inline_1.txt │ ├── min.core_opt_after_inline_2.txt │ ├── min.core_opt_after_licm.txt │ ├── min.core_opt_after_lvn.txt │ ├── min.core_opt_after_o2f.txt │ ├── min.core_opt_after_splitted_0.txt │ ├── min.core_opt_after_splitted_1.txt │ ├── min.core_opt_after_splitted_2.txt │ ├── min.core_opt_after_tre.txt │ ├── min.free_set_closure.txt │ ├── min.freg.txt │ ├── min.knf.txt │ ├── min.knf_after_inline_0.txt │ ├── min.knf_after_inline_1.txt │ ├── min.knf_after_inline_2.txt │ ├── min.knf_after_licm_0.txt │ ├── min.knf_after_licm_1.txt │ ├── min.knf_after_licm_2.txt │ ├── min.knf_after_lifting.txt │ ├── min.knf_after_unbox.txt │ ├── min.knf_to_core.txt │ ├── min.log │ ├── min.mbt │ ├── min.mcore.txt │ ├── min.resolved.txt │ ├── min.typer.txt │ ├── min.typer_simplified.txt │ ├── min.xreg.txt │ ├── multiple-init.core_opt2_after_fo.txt │ ├── multiple-init.core_opt2_after_jtbl.txt │ ├── multiple-init.core_opt2_after_lvn.txt │ ├── multiple-init.core_opt_after_dfe_0.txt │ ├── multiple-init.core_opt_after_dfe_1.txt │ ├── multiple-init.core_opt_after_dfe_2.txt │ ├── multiple-init.core_opt_after_inline_0.txt │ ├── multiple-init.core_opt_after_inline_1.txt │ ├── multiple-init.core_opt_after_inline_2.txt │ ├── multiple-init.core_opt_after_licm.txt │ ├── multiple-init.core_opt_after_lvn.txt │ ├── multiple-init.core_opt_after_o2f.txt │ ├── multiple-init.core_opt_after_splitted_0.txt │ ├── multiple-init.core_opt_after_splitted_1.txt │ ├── multiple-init.core_opt_after_splitted_2.txt │ ├── multiple-init.core_opt_after_tre.txt │ ├── multiple-init.free_set_closure.txt │ ├── multiple-init.freg.txt │ ├── multiple-init.knf.txt │ ├── multiple-init.knf_after_inline_0.txt │ ├── multiple-init.knf_after_inline_1.txt │ ├── multiple-init.knf_after_inline_2.txt │ ├── multiple-init.knf_after_licm_0.txt │ ├── multiple-init.knf_after_licm_1.txt │ ├── multiple-init.knf_after_licm_2.txt │ ├── multiple-init.knf_after_lifting.txt │ ├── multiple-init.knf_after_unbox.txt │ ├── multiple-init.knf_to_core.txt │ ├── multiple-init.log │ ├── multiple-init.mbt │ ├── multiple-init.mcore.txt │ ├── multiple-init.resolved.txt │ ├── multiple-init.typer.txt │ ├── multiple-init.typer_simplified.txt │ ├── multiple-init.xreg.txt │ ├── non-tail-if.ans │ ├── non-tail-if.core_opt2_after_fo.txt │ ├── non-tail-if.core_opt2_after_jtbl.txt │ ├── non-tail-if.core_opt2_after_lvn.txt │ ├── non-tail-if.core_opt_after_dfe_0.txt │ ├── non-tail-if.core_opt_after_dfe_1.txt │ ├── non-tail-if.core_opt_after_dfe_2.txt │ ├── non-tail-if.core_opt_after_inline_0.txt │ ├── non-tail-if.core_opt_after_inline_1.txt │ ├── non-tail-if.core_opt_after_inline_2.txt │ ├── non-tail-if.core_opt_after_licm.txt │ ├── non-tail-if.core_opt_after_lvn.txt │ ├── non-tail-if.core_opt_after_o2f.txt │ ├── non-tail-if.core_opt_after_splitted_0.txt │ ├── non-tail-if.core_opt_after_splitted_1.txt │ ├── non-tail-if.core_opt_after_splitted_2.txt │ ├── non-tail-if.core_opt_after_tre.txt │ ├── non-tail-if.free_set_closure.txt │ ├── non-tail-if.freg.txt │ ├── non-tail-if.knf.txt │ ├── non-tail-if.knf_after_inline_0.txt │ ├── non-tail-if.knf_after_inline_1.txt │ ├── non-tail-if.knf_after_inline_2.txt │ ├── non-tail-if.knf_after_licm_0.txt │ ├── non-tail-if.knf_after_licm_1.txt │ ├── non-tail-if.knf_after_licm_2.txt │ ├── non-tail-if.knf_after_lifting.txt │ ├── non-tail-if.knf_after_unbox.txt │ ├── non-tail-if.knf_to_core.txt │ ├── non-tail-if.log │ ├── non-tail-if.mbt │ ├── non-tail-if.mcore.txt │ ├── non-tail-if.resolved.txt │ ├── non-tail-if.typer.txt │ ├── non-tail-if.typer_simplified.txt │ ├── non-tail-if.xreg.txt │ ├── non-tail-if2.ans │ ├── non-tail-if2.core_opt2_after_fo.txt │ ├── non-tail-if2.core_opt2_after_jtbl.txt │ ├── non-tail-if2.core_opt2_after_lvn.txt │ ├── non-tail-if2.core_opt_after_dfe_0.txt │ ├── non-tail-if2.core_opt_after_dfe_1.txt │ ├── non-tail-if2.core_opt_after_dfe_2.txt │ ├── non-tail-if2.core_opt_after_inline_0.txt │ ├── non-tail-if2.core_opt_after_inline_1.txt │ ├── non-tail-if2.core_opt_after_inline_2.txt │ ├── non-tail-if2.core_opt_after_licm.txt │ ├── non-tail-if2.core_opt_after_lvn.txt │ ├── non-tail-if2.core_opt_after_o2f.txt │ ├── non-tail-if2.core_opt_after_splitted_0.txt │ ├── non-tail-if2.core_opt_after_splitted_1.txt │ ├── non-tail-if2.core_opt_after_splitted_2.txt │ ├── non-tail-if2.core_opt_after_tre.txt │ ├── non-tail-if2.free_set_closure.txt │ ├── non-tail-if2.freg.txt │ ├── non-tail-if2.knf.txt │ ├── non-tail-if2.knf_after_inline_0.txt │ ├── non-tail-if2.knf_after_inline_1.txt │ ├── non-tail-if2.knf_after_inline_2.txt │ ├── non-tail-if2.knf_after_licm_0.txt │ ├── non-tail-if2.knf_after_licm_1.txt │ ├── non-tail-if2.knf_after_licm_2.txt │ ├── non-tail-if2.knf_after_lifting.txt │ ├── non-tail-if2.knf_after_unbox.txt │ ├── non-tail-if2.knf_to_core.txt │ ├── non-tail-if2.log │ ├── non-tail-if2.mbt │ ├── non-tail-if2.mcore.txt │ ├── non-tail-if2.resolved.txt │ ├── non-tail-if2.typer.txt │ ├── non-tail-if2.typer_simplified.txt │ ├── non-tail-if2.xreg.txt │ ├── print.ans │ ├── print.core_opt2_after_fo.txt │ ├── print.core_opt2_after_jtbl.txt │ ├── print.core_opt2_after_lvn.txt │ ├── print.core_opt_after_dfe_0.txt │ ├── print.core_opt_after_dfe_1.txt │ ├── print.core_opt_after_dfe_2.txt │ ├── print.core_opt_after_inline_0.txt │ ├── print.core_opt_after_inline_1.txt │ ├── print.core_opt_after_inline_2.txt │ ├── print.core_opt_after_licm.txt │ ├── print.core_opt_after_lvn.txt │ ├── print.core_opt_after_o2f.txt │ ├── print.core_opt_after_splitted_0.txt │ ├── print.core_opt_after_splitted_1.txt │ ├── print.core_opt_after_splitted_2.txt │ ├── print.core_opt_after_tre.txt │ ├── print.free_set_closure.txt │ ├── print.freg.txt │ ├── print.knf.txt │ ├── print.knf_after_inline_0.txt │ ├── print.knf_after_inline_1.txt │ ├── print.knf_after_inline_2.txt │ ├── print.knf_after_licm_0.txt │ ├── print.knf_after_licm_1.txt │ ├── print.knf_after_licm_2.txt │ ├── print.knf_after_lifting.txt │ ├── print.knf_after_unbox.txt │ ├── print.knf_to_core.txt │ ├── print.log │ ├── print.mbt │ ├── print.mcore.txt │ ├── print.resolved.txt │ ├── print.typer.txt │ ├── print.typer_simplified.txt │ ├── print.xreg.txt │ ├── read.core_opt2_after_fo.txt │ ├── read.core_opt2_after_jtbl.txt │ ├── read.core_opt2_after_lvn.txt │ ├── read.core_opt_after_dfe_0.txt │ ├── read.core_opt_after_dfe_1.txt │ ├── read.core_opt_after_dfe_2.txt │ ├── read.core_opt_after_inline_0.txt │ ├── read.core_opt_after_inline_1.txt │ ├── read.core_opt_after_inline_2.txt │ ├── read.core_opt_after_licm.txt │ ├── read.core_opt_after_lvn.txt │ ├── read.core_opt_after_o2f.txt │ ├── read.core_opt_after_splitted_0.txt │ ├── read.core_opt_after_splitted_1.txt │ ├── read.core_opt_after_splitted_2.txt │ ├── read.core_opt_after_tre.txt │ ├── read.free_set_closure.txt │ ├── read.freg.txt │ ├── read.knf.txt │ ├── read.knf_after_inline_0.txt │ ├── read.knf_after_inline_1.txt │ ├── read.knf_after_inline_2.txt │ ├── read.knf_after_licm_0.txt │ ├── read.knf_after_licm_1.txt │ ├── read.knf_after_licm_2.txt │ ├── read.knf_after_lifting.txt │ ├── read.knf_after_unbox.txt │ ├── read.knf_to_core.txt │ ├── read.log │ ├── read.mbt │ ├── read.mcore.txt │ ├── read.resolved.txt │ ├── read.typer.txt │ ├── read.typer_simplified.txt │ ├── read.xreg.txt │ ├── shuffle.ans │ ├── shuffle.core_opt2_after_fo.txt │ ├── shuffle.core_opt2_after_jtbl.txt │ ├── shuffle.core_opt2_after_lvn.txt │ ├── shuffle.core_opt_after_dfe_0.txt │ ├── shuffle.core_opt_after_dfe_1.txt │ ├── shuffle.core_opt_after_dfe_2.txt │ ├── shuffle.core_opt_after_inline_0.txt │ ├── shuffle.core_opt_after_inline_1.txt │ ├── shuffle.core_opt_after_inline_2.txt │ ├── shuffle.core_opt_after_licm.txt │ ├── shuffle.core_opt_after_lvn.txt │ ├── shuffle.core_opt_after_o2f.txt │ ├── shuffle.core_opt_after_splitted_0.txt │ ├── shuffle.core_opt_after_splitted_1.txt │ ├── shuffle.core_opt_after_splitted_2.txt │ ├── shuffle.core_opt_after_tre.txt │ ├── shuffle.free_set_closure.txt │ ├── shuffle.freg.txt │ ├── shuffle.knf.txt │ ├── shuffle.knf_after_inline_0.txt │ ├── shuffle.knf_after_inline_1.txt │ ├── shuffle.knf_after_inline_2.txt │ ├── shuffle.knf_after_licm_0.txt │ ├── shuffle.knf_after_licm_1.txt │ ├── shuffle.knf_after_licm_2.txt │ ├── shuffle.knf_after_lifting.txt │ ├── shuffle.knf_after_unbox.txt │ ├── shuffle.knf_to_core.txt │ ├── shuffle.log │ ├── shuffle.mbt │ ├── shuffle.mcore.txt │ ├── shuffle.resolved.txt │ ├── shuffle.typer.txt │ ├── shuffle.typer_simplified.txt │ ├── shuffle.xreg.txt │ ├── ski.knf.txt │ ├── ski.log │ ├── ski.mbt │ ├── ski.resolved.txt │ ├── ski.typer.txt │ ├── ski.typer_simplified.txt │ ├── spill.ans │ ├── spill.core_opt2_after_fo.txt │ ├── spill.core_opt2_after_jtbl.txt │ ├── spill.core_opt2_after_lvn.txt │ ├── spill.core_opt_after_dfe_0.txt │ ├── spill.core_opt_after_dfe_1.txt │ ├── spill.core_opt_after_dfe_2.txt │ ├── spill.core_opt_after_inline_0.txt │ ├── spill.core_opt_after_inline_1.txt │ ├── spill.core_opt_after_inline_2.txt │ ├── spill.core_opt_after_licm.txt │ ├── spill.core_opt_after_lvn.txt │ ├── spill.core_opt_after_o2f.txt │ ├── spill.core_opt_after_splitted_0.txt │ ├── spill.core_opt_after_splitted_1.txt │ ├── spill.core_opt_after_splitted_2.txt │ ├── spill.core_opt_after_tre.txt │ ├── spill.free_set_closure.txt │ ├── spill.freg.txt │ ├── spill.knf.txt │ ├── spill.knf_after_inline_0.txt │ ├── spill.knf_after_inline_1.txt │ ├── spill.knf_after_inline_2.txt │ ├── spill.knf_after_licm_0.txt │ ├── spill.knf_after_licm_1.txt │ ├── spill.knf_after_licm_2.txt │ ├── spill.knf_after_lifting.txt │ ├── spill.knf_after_unbox.txt │ ├── spill.knf_to_core.txt │ ├── spill.log │ ├── spill.mbt │ ├── spill.mcore.txt │ ├── spill.resolved.txt │ ├── spill.typer.txt │ ├── spill.typer_simplified.txt │ ├── spill.xreg.txt │ ├── spill2.ans │ ├── spill2.core_opt2_after_fo.txt │ ├── spill2.core_opt2_after_jtbl.txt │ ├── spill2.core_opt2_after_lvn.txt │ ├── spill2.core_opt_after_dfe_0.txt │ ├── spill2.core_opt_after_dfe_1.txt │ ├── spill2.core_opt_after_dfe_2.txt │ ├── spill2.core_opt_after_inline_0.txt │ ├── spill2.core_opt_after_inline_1.txt │ ├── spill2.core_opt_after_inline_2.txt │ ├── spill2.core_opt_after_licm.txt │ ├── spill2.core_opt_after_lvn.txt │ ├── spill2.core_opt_after_o2f.txt │ ├── spill2.core_opt_after_splitted_0.txt │ ├── spill2.core_opt_after_splitted_1.txt │ ├── spill2.core_opt_after_splitted_2.txt │ ├── spill2.core_opt_after_tre.txt │ ├── spill2.free_set_closure.txt │ ├── spill2.freg.txt │ ├── spill2.knf.txt │ ├── spill2.knf_after_inline_0.txt │ ├── spill2.knf_after_inline_1.txt │ ├── spill2.knf_after_inline_2.txt │ ├── spill2.knf_after_licm_0.txt │ ├── spill2.knf_after_licm_1.txt │ ├── spill2.knf_after_licm_2.txt │ ├── spill2.knf_after_lifting.txt │ ├── spill2.knf_after_unbox.txt │ ├── spill2.knf_to_core.txt │ ├── spill2.log │ ├── spill2.mbt │ ├── spill2.mcore.txt │ ├── spill2.resolved.txt │ ├── spill2.typer.txt │ ├── spill2.typer_simplified.txt │ ├── spill2.xreg.txt │ ├── spill3.ans │ ├── spill3.core_opt2_after_fo.txt │ ├── spill3.core_opt2_after_jtbl.txt │ ├── spill3.core_opt2_after_lvn.txt │ ├── spill3.core_opt_after_dfe_0.txt │ ├── spill3.core_opt_after_dfe_1.txt │ ├── spill3.core_opt_after_dfe_2.txt │ ├── spill3.core_opt_after_inline_0.txt │ ├── spill3.core_opt_after_inline_1.txt │ ├── spill3.core_opt_after_inline_2.txt │ ├── spill3.core_opt_after_licm.txt │ ├── spill3.core_opt_after_lvn.txt │ ├── spill3.core_opt_after_o2f.txt │ ├── spill3.core_opt_after_splitted_0.txt │ ├── spill3.core_opt_after_splitted_1.txt │ ├── spill3.core_opt_after_splitted_2.txt │ ├── spill3.core_opt_after_tre.txt │ ├── spill3.free_set_closure.txt │ ├── spill3.freg.txt │ ├── spill3.knf.txt │ ├── spill3.knf_after_inline_0.txt │ ├── spill3.knf_after_inline_1.txt │ ├── spill3.knf_after_inline_2.txt │ ├── spill3.knf_after_licm_0.txt │ ├── spill3.knf_after_licm_1.txt │ ├── spill3.knf_after_licm_2.txt │ ├── spill3.knf_after_lifting.txt │ ├── spill3.knf_after_unbox.txt │ ├── spill3.knf_to_core.txt │ ├── spill3.log │ ├── spill3.mbt │ ├── spill3.mcore.txt │ ├── spill3.resolved.txt │ ├── spill3.typer.txt │ ├── spill3.typer_simplified.txt │ ├── spill3.xreg.txt │ ├── split.core_opt2_after_fo.txt │ ├── split.core_opt2_after_jtbl.txt │ ├── split.core_opt2_after_lvn.txt │ ├── split.core_opt_after_dfe_0.txt │ ├── split.core_opt_after_dfe_1.txt │ ├── split.core_opt_after_dfe_2.txt │ ├── split.core_opt_after_inline_0.txt │ ├── split.core_opt_after_inline_1.txt │ ├── split.core_opt_after_inline_2.txt │ ├── split.core_opt_after_licm.txt │ ├── split.core_opt_after_lvn.txt │ ├── split.core_opt_after_o2f.txt │ ├── split.core_opt_after_splitted_0.txt │ ├── split.core_opt_after_splitted_1.txt │ ├── split.core_opt_after_splitted_2.txt │ ├── split.core_opt_after_tre.txt │ ├── split.free_set_closure.txt │ ├── split.freg.txt │ ├── split.knf.txt │ ├── split.knf_after_inline_0.txt │ ├── split.knf_after_inline_1.txt │ ├── split.knf_after_inline_2.txt │ ├── split.knf_after_licm_0.txt │ ├── split.knf_after_licm_1.txt │ ├── split.knf_after_licm_2.txt │ ├── split.knf_after_lifting.txt │ ├── split.knf_after_unbox.txt │ ├── split.knf_to_core.txt │ ├── split.log │ ├── split.mbt │ ├── split.mcore.txt │ ├── split.resolved.txt │ ├── split.typer.txt │ ├── split.typer_simplified.txt │ ├── split.xreg.txt │ ├── string.knf.txt │ ├── string.log │ ├── string.mbt │ ├── string.resolved.txt │ ├── string.typer.txt │ ├── string.typer_simplified.txt │ ├── sum-prefix-escape.core_opt2_after_fo.txt │ ├── sum-prefix-escape.core_opt2_after_jtbl.txt │ ├── sum-prefix-escape.core_opt2_after_lvn.txt │ ├── sum-prefix-escape.core_opt_after_dfe_0.txt │ ├── sum-prefix-escape.core_opt_after_dfe_1.txt │ ├── sum-prefix-escape.core_opt_after_dfe_2.txt │ ├── sum-prefix-escape.core_opt_after_inline_0.txt │ ├── sum-prefix-escape.core_opt_after_inline_1.txt │ ├── sum-prefix-escape.core_opt_after_inline_2.txt │ ├── sum-prefix-escape.core_opt_after_licm.txt │ ├── sum-prefix-escape.core_opt_after_lvn.txt │ ├── sum-prefix-escape.core_opt_after_o2f.txt │ ├── sum-prefix-escape.core_opt_after_splitted_0.txt │ ├── sum-prefix-escape.core_opt_after_splitted_1.txt │ ├── sum-prefix-escape.core_opt_after_splitted_2.txt │ ├── sum-prefix-escape.core_opt_after_tre.txt │ ├── sum-prefix-escape.free_set_closure.txt │ ├── sum-prefix-escape.freg.txt │ ├── sum-prefix-escape.knf.txt │ ├── sum-prefix-escape.knf_after_inline_0.txt │ ├── sum-prefix-escape.knf_after_inline_1.txt │ ├── sum-prefix-escape.knf_after_inline_2.txt │ ├── sum-prefix-escape.knf_after_licm_0.txt │ ├── sum-prefix-escape.knf_after_licm_1.txt │ ├── sum-prefix-escape.knf_after_licm_2.txt │ ├── sum-prefix-escape.knf_after_lifting.txt │ ├── sum-prefix-escape.knf_after_unbox.txt │ ├── sum-prefix-escape.knf_to_core.txt │ ├── sum-prefix-escape.log │ ├── sum-prefix-escape.mbt │ ├── sum-prefix-escape.mcore.txt │ ├── sum-prefix-escape.resolved.txt │ ├── sum-prefix-escape.typer.txt │ ├── sum-prefix-escape.typer_simplified.txt │ ├── sum-prefix-escape.xreg.txt │ ├── sum-tail.ans │ ├── sum-tail.core_opt2_after_fo.txt │ ├── sum-tail.core_opt2_after_jtbl.txt │ ├── sum-tail.core_opt2_after_lvn.txt │ ├── sum-tail.core_opt_after_dfe_0.txt │ ├── sum-tail.core_opt_after_dfe_1.txt │ ├── sum-tail.core_opt_after_dfe_2.txt │ ├── sum-tail.core_opt_after_inline_0.txt │ ├── sum-tail.core_opt_after_inline_1.txt │ ├── sum-tail.core_opt_after_inline_2.txt │ ├── sum-tail.core_opt_after_licm.txt │ ├── sum-tail.core_opt_after_lvn.txt │ ├── sum-tail.core_opt_after_o2f.txt │ ├── sum-tail.core_opt_after_splitted_0.txt │ ├── sum-tail.core_opt_after_splitted_1.txt │ ├── sum-tail.core_opt_after_splitted_2.txt │ ├── sum-tail.core_opt_after_tre.txt │ ├── sum-tail.free_set_closure.txt │ ├── sum-tail.freg.txt │ ├── sum-tail.knf.txt │ ├── sum-tail.knf_after_inline_0.txt │ ├── sum-tail.knf_after_inline_1.txt │ ├── sum-tail.knf_after_inline_2.txt │ ├── sum-tail.knf_after_licm_0.txt │ ├── sum-tail.knf_after_licm_1.txt │ ├── sum-tail.knf_after_licm_2.txt │ ├── sum-tail.knf_after_lifting.txt │ ├── sum-tail.knf_after_unbox.txt │ ├── sum-tail.knf_to_core.txt │ ├── sum-tail.log │ ├── sum-tail.mbt │ ├── sum-tail.mcore.txt │ ├── sum-tail.resolved.txt │ ├── sum-tail.typer.txt │ ├── sum-tail.typer_simplified.txt │ ├── sum-tail.xreg.txt │ ├── sum.ans │ ├── sum.core_opt2_after_fo.txt │ ├── sum.core_opt2_after_jtbl.txt │ ├── sum.core_opt2_after_lvn.txt │ ├── sum.core_opt_after_dfe_0.txt │ ├── sum.core_opt_after_dfe_1.txt │ ├── sum.core_opt_after_dfe_2.txt │ ├── sum.core_opt_after_inline_0.txt │ ├── sum.core_opt_after_inline_1.txt │ ├── sum.core_opt_after_inline_2.txt │ ├── sum.core_opt_after_licm.txt │ ├── sum.core_opt_after_lvn.txt │ ├── sum.core_opt_after_o2f.txt │ ├── sum.core_opt_after_splitted_0.txt │ ├── sum.core_opt_after_splitted_1.txt │ ├── sum.core_opt_after_splitted_2.txt │ ├── sum.core_opt_after_tre.txt │ ├── sum.free_set_closure.txt │ ├── sum.freg.txt │ ├── sum.knf.txt │ ├── sum.knf_after_inline_0.txt │ ├── sum.knf_after_inline_1.txt │ ├── sum.knf_after_inline_2.txt │ ├── sum.knf_after_licm_0.txt │ ├── sum.knf_after_licm_1.txt │ ├── sum.knf_after_licm_2.txt │ ├── sum.knf_after_lifting.txt │ ├── sum.knf_after_unbox.txt │ ├── sum.knf_to_core.txt │ ├── sum.log │ ├── sum.mbt │ ├── sum.mcore.txt │ ├── sum.resolved.txt │ ├── sum.typer.txt │ ├── sum.typer_simplified.txt │ ├── sum.xreg.txt │ ├── typeclass.knf.txt │ ├── typeclass.log │ ├── typeclass.mbt │ ├── typeclass.resolved.txt │ ├── typeclass.typer.txt │ ├── typeclass.typer_simplified.txt │ ├── typeclass2.knf.txt │ ├── typeclass2.log │ ├── typeclass2.mbt │ ├── typeclass2.resolved.txt │ ├── typeclass2.typer.txt │ ├── typeclass2.typer_simplified.txt │ ├── user_defined_op.core_opt2_after_fo.txt │ ├── user_defined_op.core_opt2_after_jtbl.txt │ ├── user_defined_op.core_opt2_after_lvn.txt │ ├── user_defined_op.core_opt_after_dfe_0.txt │ ├── user_defined_op.core_opt_after_dfe_1.txt │ ├── user_defined_op.core_opt_after_dfe_2.txt │ ├── user_defined_op.core_opt_after_inline_0.txt │ ├── user_defined_op.core_opt_after_inline_1.txt │ ├── user_defined_op.core_opt_after_inline_2.txt │ ├── user_defined_op.core_opt_after_licm.txt │ ├── user_defined_op.core_opt_after_lvn.txt │ ├── user_defined_op.core_opt_after_o2f.txt │ ├── user_defined_op.core_opt_after_splitted_0.txt │ ├── user_defined_op.core_opt_after_splitted_1.txt │ ├── user_defined_op.core_opt_after_splitted_2.txt │ ├── user_defined_op.core_opt_after_tre.txt │ ├── user_defined_op.free_set_closure.txt │ ├── user_defined_op.freg.txt │ ├── user_defined_op.knf.txt │ ├── user_defined_op.knf_after_inline_0.txt │ ├── user_defined_op.knf_after_inline_1.txt │ ├── user_defined_op.knf_after_inline_2.txt │ ├── user_defined_op.knf_after_licm_0.txt │ ├── user_defined_op.knf_after_licm_1.txt │ ├── user_defined_op.knf_after_licm_2.txt │ ├── user_defined_op.knf_after_lifting.txt │ ├── user_defined_op.knf_after_unbox.txt │ ├── user_defined_op.knf_to_core.txt │ ├── user_defined_op.log │ ├── user_defined_op.mbt │ ├── user_defined_op.mcore.txt │ ├── user_defined_op.resolved.txt │ ├── user_defined_op.typer.txt │ ├── user_defined_op.typer_simplified.txt │ └── user_defined_op.xreg.txt └── wasm_rt └── runtime.mjs /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode/ 2 | 3 | .DS_Store 4 | 5 | # moonbit 6 | target/ 7 | .mooncakes/ 8 | failed_tests/ 9 | rv64_failed_tests/ 10 | *.S 11 | *.wat 12 | *.wasm 13 | 14 | __pycache__ 15 | submit-*.zip 16 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "libriscv"] 2 | path = libriscv 3 | url = https://github.com/fwsGonzo/libriscv 4 | -------------------------------------------------------------------------------- /.moonbit-lsp.json: -------------------------------------------------------------------------------- 1 | { 2 | "backend": "wasm-gc" 3 | } -------------------------------------------------------------------------------- /TODO.md: -------------------------------------------------------------------------------- 1 | # TODO 2 | 3 | ## Potential issues 4 | 5 | ## Potential improvements 6 | 7 | A specializer? 8 | -------------------------------------------------------------------------------- /bf.py: -------------------------------------------------------------------------------- 1 | m = { 2 | '>': 1, 3 | '<': 2, 4 | '+': 3, 5 | '-': 4, 6 | '.': 5, 7 | ',': 6, 8 | '[': 7, 9 | ']': 8 10 | } 11 | 12 | def convert(prog): 13 | return [m[c] for c in prog] 14 | 15 | def pp(prog): 16 | for i, n in enumerate(prog): 17 | print(f'prog[{i}] = {n};') 18 | 19 | def bf(prog): 20 | pp(convert(prog)) 21 | 22 | prog = '++++++++[>++++++++<-]>.' 23 | bf(prog) 24 | -------------------------------------------------------------------------------- /build_riscvrt.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | pushd riscv_rt 4 | zig build 5 | popd 6 | ln -fs riscv_rt/zig-out/bin/rvelf . 7 | -------------------------------------------------------------------------------- /build_rvlinux.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | pushd libriscv/emulator 4 | ./build.sh --native --64 -b -v 5 | popd 6 | ln -fs libriscv/emulator/.build/rvlinux . 7 | -------------------------------------------------------------------------------- /conf.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | keys = [ 4 | "use_xthead", 5 | "knf_inline", 6 | "knf_licm", 7 | "knf_lift", 8 | "knf_unbox", 9 | "core_inline", 10 | "core_licm", 11 | "core_lvn", 12 | "core_2_fo", 13 | "core_2_jtbl", 14 | "core_2_lvn", 15 | ] 16 | 17 | with open('mmm.json') as f: 18 | conf = json.load(f) 19 | conf_str = "conf_" 20 | for key in keys: 21 | if key in conf: 22 | x = conf[key] 23 | if type(x) is bool and x: 24 | x = "t" 25 | elif type(x) is bool and not x: 26 | x = "f" 27 | conf_str += f"{x}" 28 | print(conf_str) -------------------------------------------------------------------------------- /configure/default.json: -------------------------------------------------------------------------------- 1 | { 2 | "use_xthead": true, 3 | "knf_inline": 3, 4 | "knf_licm": 3, 5 | "knf_lift": true, 6 | "knf_unbox": true, 7 | "core_inline": 3, 8 | "core_licm": true, 9 | "core_lvn": true, 10 | "core_2_fo": true, 11 | "core_2_jtbl": false, 12 | "core_2_lvn": true 13 | } -------------------------------------------------------------------------------- /configure/disable_inline.json: -------------------------------------------------------------------------------- 1 | { 2 | "use_xthead": false, 3 | "knf_inline": 0, 4 | "knf_licm": 0, 5 | "knf_lift": false, 6 | "knf_unbox": false, 7 | "core_inline": 0, 8 | "core_licm": false, 9 | "core_lvn": false, 10 | "core_2_fo": false, 11 | "core_2_jtbl": false, 12 | "core_2_lvn": false 13 | } -------------------------------------------------------------------------------- /configure/disable_knf_opt.json: -------------------------------------------------------------------------------- 1 | { 2 | "use_xthead": true, 3 | "knf_inline": 3, 4 | "knf_licm": 0, 5 | "knf_lift": false, 6 | "knf_unbox": false, 7 | "core_inline": 3, 8 | "core_licm": true, 9 | "core_lvn": true, 10 | "core_2_fo": true, 11 | "core_2_jtbl": false, 12 | "core_2_lvn": true 13 | } -------------------------------------------------------------------------------- /configure/disable_opt.json: -------------------------------------------------------------------------------- 1 | { 2 | "use_xthead": true, 3 | "knf_inline": 3, 4 | "knf_licm": 0, 5 | "knf_lift": false, 6 | "knf_unbox": false, 7 | "core_inline": 3, 8 | "core_licm": false, 9 | "core_lvn": false, 10 | "core_2_fo": false, 11 | "core_2_jtbl": false, 12 | "core_2_lvn": false 13 | } -------------------------------------------------------------------------------- /configure/disable_xthead.json: -------------------------------------------------------------------------------- 1 | { 2 | "use_xthead": false, 3 | "knf_inline": 3, 4 | "knf_licm": 0, 5 | "knf_lift": false, 6 | "knf_unbox": false, 7 | "core_inline": 3, 8 | "core_licm": false, 9 | "core_lvn": false, 10 | "core_2_fo": false, 11 | "core_2_jtbl": false, 12 | "core_2_lvn": false 13 | } -------------------------------------------------------------------------------- /debug.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | rm -f out 3 | moon run -g src/bin/main.mbt -- $1 -o $1.S 4 | zig build-exe -target riscv64-linux -femit-bin=out riscv_rt/zig-out/lib/libmincaml.a $1.S -O Debug -fno-strip -mcpu=baseline_rv64 5 | ./rvlinux -n out 6 | -------------------------------------------------------------------------------- /debug2.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | rm -f out 3 | moon run -g src/bin/main.mbt -- --end-stage wasm $1 -o $1.wat -------------------------------------------------------------------------------- /debug3.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -e 3 | rm -f out 4 | moon run -g src/bin/main.mbt -- --end-stage riscv $1 -o $1.S 5 | zig build-exe -target riscv64-linux -femit-bin=out riscv_rt/zig-out/lib/libmincaml.a $1.S -O Debug -fno-strip -mcpu=baseline_rv64 6 | scp ./out rvvm:~ 7 | scp $1.S rvvm:~ 8 | scp ${1%.*}.in rvvm:~ 9 | scp ${1%.*}.ans rvvm:~ 10 | ssh rvvm -------------------------------------------------------------------------------- /js_rt/test.mjs: -------------------------------------------------------------------------------- 1 | export default function () { 2 | console.log("Hello, World!"); 3 | } 4 | -------------------------------------------------------------------------------- /make_submit.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | for file in configure/*.json 4 | do 5 | echo "Make submission file with conf $file" 6 | cp -f $file mmm.json 7 | ./submit.sh 8 | done 9 | 10 | cp -f configure/default.json mmm.json 11 | -------------------------------------------------------------------------------- /mmm.json: -------------------------------------------------------------------------------- 1 | { 2 | "use_xthead": true, 3 | "knf_inline": 3, 4 | "knf_licm": 3, 5 | "knf_lift": true, 6 | "knf_unbox": true, 7 | "core_inline": 3, 8 | "core_licm": true, 9 | "core_lvn": true, 10 | "core_2_fo": true, 11 | "core_2_jtbl": false, 12 | "core_2_lvn": true 13 | } -------------------------------------------------------------------------------- /moon.mod.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "moonbitlang/minimbt", 3 | "version": "0.1.0", 4 | "deps": { 5 | "lijunchen/unstable_io": "0.1.3", 6 | "Yoorkin/ArgParser": "0.1.6" 7 | }, 8 | "readme": "README.md", 9 | "license": "Apache-2.0", 10 | "description": "", 11 | "source": "src" 12 | } 13 | -------------------------------------------------------------------------------- /riscv_rt/.gitignore: -------------------------------------------------------------------------------- 1 | .zig-cache/ 2 | zig-out/ -------------------------------------------------------------------------------- /riscv_rt/src/start.zig: -------------------------------------------------------------------------------- 1 | const std = @import("std"); 2 | const lib = @import("./lib.zig"); 3 | 4 | extern fn minimbt_main() void; 5 | 6 | pub fn main() void { 7 | lib.init_allocator(); 8 | minimbt_main(); 9 | lib.deinit_allocator(); 10 | } 11 | -------------------------------------------------------------------------------- /riscv_rt/test/float_int.s: -------------------------------------------------------------------------------- 1 | .global mincaml_main 2 | 3 | mincaml_main: 4 | li a0, 1 5 | call mincaml_float_of_int 6 | call mincaml_int_of_float 7 | call mincaml_print_int 8 | li a0, 0 9 | li a7, 93 10 | ecall 11 | -------------------------------------------------------------------------------- /riscv_rt/test/malloc.s: -------------------------------------------------------------------------------- 1 | .global mincaml_main 2 | 3 | mincaml_main: 4 | li a0, 1024 5 | call mincaml_malloc 6 | li t0, 777 7 | sw t0, 0(a0) 8 | lw a0, 0(a0) 9 | call mincaml_print_int 10 | li a7, 93 11 | ecall 12 | -------------------------------------------------------------------------------- /riscv_rt/test/print_int.s: -------------------------------------------------------------------------------- 1 | .global mincaml_main 2 | 3 | mincaml_main: 4 | li a0, 666 5 | call mincaml_print_int 6 | li a0, 0 7 | li a7, 93 8 | ecall 9 | -------------------------------------------------------------------------------- /run-islec.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env sh 2 | 3 | echo "Generating src/lower/riscv/generated/generated.mbt" 4 | islec src/core/prelude.isle src/core/core.isle src/riscv/riscv.isle src/lower/riscv/lower.isle > src/lower/riscv/generated/generated.mbt 5 | echo "Done" 6 | 7 | -------------------------------------------------------------------------------- /src/bin/bin.mbti: -------------------------------------------------------------------------------- 1 | package moonbitlang/minimbt/bin 2 | 3 | // Values 4 | 5 | // Types and methods 6 | type CompileStatus 7 | 8 | type Flags 9 | 10 | type Options 11 | 12 | type Stages 13 | impl Stages { 14 | op_equal(Self, Self) -> Bool 15 | to_string(Self) -> String 16 | } 17 | 18 | type StagesMode 19 | impl StagesMode { 20 | op_equal(Self, Self) -> Bool 21 | to_string(Self) -> String 22 | } 23 | 24 | // Type aliases 25 | 26 | // Traits 27 | 28 | // Extension Methods 29 | impl Show for Stages 30 | 31 | impl Show for StagesMode 32 | 33 | -------------------------------------------------------------------------------- /src/closure/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | { 4 | "path": "moonbitlang/minimbt", 5 | "alias": "types" 6 | }, 7 | "moonbitlang/minimbt/knf", 8 | "moonbitlang/minimbt/util" 9 | ] 10 | } 11 | -------------------------------------------------------------------------------- /src/closure_eval/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | { 4 | "path": "moonbitlang/minimbt", 5 | "alias": "types" 6 | }, 7 | "moonbitlang/minimbt/closure", 8 | "moonbitlang/minimbt/util" 9 | ], 10 | "test-import": [ 11 | "moonbitlang/minimbt/knf", 12 | "moonbitlang/minimbt/parser", 13 | "moonbitlang/minimbt/lexer", 14 | "moonbitlang/minimbt/typer" 15 | ] 16 | } 17 | -------------------------------------------------------------------------------- /src/core/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | { 4 | "path": "moonbitlang/minimbt", 5 | "alias": "types" 6 | }, 7 | "moonbitlang/minimbt/knf", 8 | "moonbitlang/minimbt/closure", 9 | "moonbitlang/minimbt/util", 10 | "moonbitlang/minimbt/typer" 11 | ], 12 | "test-import": [ 13 | "moonbitlang/minimbt/parser" 14 | ] 15 | } -------------------------------------------------------------------------------- /src/core/prelude.isle: -------------------------------------------------------------------------------- 1 | (type Unit (primitive Unit)) 2 | 3 | (type Bool (primitive Bool)) 4 | (extern const $true Bool) 5 | (extern const $false Bool) 6 | 7 | (type UInt8 (primitive Char)) 8 | (type UInt32 (primitive UInt)) 9 | (type UInt64 (primitive UInt64)) 10 | 11 | (type Int8 (primitive Char)) 12 | (type Int32 (primitive Int)) 13 | (type Int64 (primitive Int64)) 14 | 15 | (type Float (primitive Float)) 16 | (type Double (primitive Double)) -------------------------------------------------------------------------------- /src/core_analysis/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/core", 4 | "moonbitlang/minimbt/util" 5 | ], 6 | "test-import": [ 7 | ] 8 | } -------------------------------------------------------------------------------- /src/core_eval/fast_interp.txt: -------------------------------------------------------------------------------- 1 | // Uninit: 0, _ 2 | // Unit: 1, _ 3 | // Int32: 2, val 4 | // Int64: 3, val 5 | // Bool: 2, val 6 | // Double: 4, val 7 | // FnPtr: 5, val 8 | // Mem: 6, ref 9 | 10 | type FObj (Int, Int64) 11 | 12 | type FValue 13 | 14 | type FInsn (Int, Int64, Int64) 15 | 16 | type Args Array[FObj] 17 | 18 | pub struct FCtx { 19 | heap : Array[FObj] 20 | global : Array[FObj] 21 | funcs : Array[Fn] 22 | insns : Array[FObj] 23 | blkargs : Array[Array[FObj]] 24 | fnargs : Array[FObj] 25 | closure : FObj 26 | args : Array[Args] 27 | } 28 | -------------------------------------------------------------------------------- /src/core_eval/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/core", 4 | "moonbitlang/minimbt/knf", 5 | { 6 | "path": "moonbitlang/minimbt", 7 | "alias": "types" 8 | }, 9 | "moonbitlang/minimbt/util", 10 | "moonbitlang/minimbt/typer" 11 | ], 12 | "test-import": [ 13 | "moonbitlang/minimbt/parser", 14 | "moonbitlang/minimbt/lexer", 15 | "moonbitlang/minimbt/typer" 16 | ] 17 | } -------------------------------------------------------------------------------- /src/core_opt/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/core_analysis", 4 | "moonbitlang/minimbt/core", 5 | "moonbitlang/minimbt/knf", 6 | { 7 | "path": "moonbitlang/minimbt", 8 | "alias": "types" 9 | }, 10 | "moonbitlang/minimbt/util", 11 | "moonbitlang/minimbt/typer", 12 | "moonbitlang/minimbt/riscv" 13 | ], 14 | "test-import": [ 15 | "moonbitlang/minimbt/parser", 16 | "moonbitlang/minimbt/lexer", 17 | "moonbitlang/minimbt/typer" 18 | ] 19 | } -------------------------------------------------------------------------------- /src/knf/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | { 4 | "path": "moonbitlang/minimbt", 5 | "alias": "types" 6 | }, 7 | "moonbitlang/minimbt/util", 8 | "moonbitlang/minimbt/parser", 9 | "moonbitlang/minimbt/typer" 10 | ], 11 | "test-import": [ 12 | "moonbitlang/minimbt/parser", 13 | "moonbitlang/minimbt/lexer", 14 | "moonbitlang/minimbt/typer" 15 | ] 16 | } 17 | -------------------------------------------------------------------------------- /src/knf_eval/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/knf", 4 | { 5 | "path": "moonbitlang/minimbt", 6 | "alias": "types" 7 | }, 8 | "moonbitlang/minimbt/util" 9 | ], 10 | "test-import": [ 11 | "moonbitlang/minimbt/parser", 12 | "moonbitlang/minimbt/lexer", 13 | "moonbitlang/minimbt/typer" 14 | ] 15 | } 16 | -------------------------------------------------------------------------------- /src/lexer/moon.pkg.json: -------------------------------------------------------------------------------- 1 | {} -------------------------------------------------------------------------------- /src/lower/js/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt", 4 | "moonbitlang/minimbt/core", 5 | "moonbitlang/minimbt/riscv", 6 | "moonbitlang/minimbt/lower", 7 | "moonbitlang/minimbt/core_analysis", 8 | "moonbitlang/minimbt/parser", 9 | "moonbitlang/minimbt/util", 10 | "moonbitlang/minimbt/knf" 11 | ] 12 | } -------------------------------------------------------------------------------- /src/lower/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/core", 4 | "moonbitlang/minimbt/riscv", 5 | "moonbitlang/minimbt/core_analysis", 6 | "moonbitlang/minimbt/util" 7 | ] 8 | } 9 | -------------------------------------------------------------------------------- /src/lower/riscv/generated/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "warn-list": "-1-2-7-8-10-12", 3 | "import": [ 4 | "moonbitlang/minimbt/core", 5 | "moonbitlang/minimbt/riscv", 6 | "moonbitlang/minimbt/lower" 7 | ] 8 | } -------------------------------------------------------------------------------- /src/lower/riscv/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/core", 4 | "moonbitlang/minimbt/riscv", 5 | "moonbitlang/minimbt/lower", 6 | "moonbitlang/minimbt/lower/riscv/generated", 7 | "moonbitlang/minimbt/core_analysis", 8 | "moonbitlang/minimbt/parser", 9 | "moonbitlang/minimbt/util", 10 | { 11 | "path": "moonbitlang/minimbt", 12 | "alias": "types" 13 | }, 14 | ] 15 | } -------------------------------------------------------------------------------- /src/lower/wasm/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/core", 4 | "moonbitlang/minimbt/lower", 5 | "moonbitlang/minimbt/core_analysis", 6 | "moonbitlang/minimbt/util" 7 | ] 8 | } -------------------------------------------------------------------------------- /src/magic/magic.mbt: -------------------------------------------------------------------------------- 1 | extern "wasm" fn ffi(n : Int) -> Int = 2 | #| (func i32.const 0 drop) 3 | 4 | pub fn exit(n : Int) -> Unit { 5 | let _ = ffi(n) 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/magic/magic.mbti: -------------------------------------------------------------------------------- 1 | package moonbitlang/minimbt/magic 2 | 3 | // Values 4 | fn exit(Int) -> Unit 5 | 6 | // Types and methods 7 | 8 | // Type aliases 9 | 10 | // Traits 11 | 12 | // Extension Methods 13 | 14 | -------------------------------------------------------------------------------- /src/magic/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [] 3 | } 4 | -------------------------------------------------------------------------------- /src/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/util" 4 | ] 5 | } 6 | -------------------------------------------------------------------------------- /src/parser/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/lexer", 4 | { 5 | "path": "moonbitlang/minimbt", 6 | "alias": "types" 7 | }, 8 | "moonbitlang/minimbt/util" 9 | ] 10 | } 11 | -------------------------------------------------------------------------------- /src/riscv/asm_stringify.mbt: -------------------------------------------------------------------------------- 1 | pub fn print_functions(asm : Array[AssemblyFunction]) -> String { 2 | let logger = Buffer::new() 3 | for f in asm { 4 | f.output(logger) 5 | logger.write_string("\n") 6 | } 7 | logger.to_string() 8 | } 9 | -------------------------------------------------------------------------------- /src/riscv/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | "moonbitlang/minimbt/core", 4 | { 5 | "path": "moonbitlang/minimbt", 6 | "alias": "typing" 7 | }, 8 | "moonbitlang/minimbt/util", 9 | "lijunchen/unstable_io/env" 10 | ] 11 | } 12 | -------------------------------------------------------------------------------- /src/typer/moon.pkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "import": [ 3 | { 4 | "path": "moonbitlang/minimbt", 5 | "alias": "types" 6 | }, 7 | "moonbitlang/minimbt/util" 8 | ], 9 | "test-import": [ 10 | "moonbitlang/minimbt/lexer", 11 | "moonbitlang/minimbt/parser" 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /src/util/error.mbt: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /src/util/moon.pkg.json: -------------------------------------------------------------------------------- 1 | {} -------------------------------------------------------------------------------- /start-rvvm.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | pushd ~/Projects/rvvm/build 3 | ./rvvm fw_payload.bin -i archriscv.img -m 2G -portfwd tcp/127.0.0.1:2022=22 4 | popd -------------------------------------------------------------------------------- /submit.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -ex 3 | if [ "$#" -eq 0 ]; then 4 | stash=$(git stash create) 5 | filename="submit-$(git rev-parse --short $stash)-$(python conf.py).zip" 6 | git archive -o $filename $stash ./src ./moon.mod.json ./mmm.json 7 | fi 8 | if [ "$#" -eq 1 ]; then 9 | filename="submit-$(git rev-parse --short $1)-$(python conf.py).zip" 10 | git archive -o $filename $1 ./src ./moon.mod.json ./mmm.json 11 | fi 12 | -------------------------------------------------------------------------------- /subst.py: -------------------------------------------------------------------------------- 1 | assignment = 'v3<-a3;v10<-a0;v12<-a0;v27<-a0;v7<-a1;v15<-a0;v6<-a4;v5<-a0;v25<-a0;v11<-a0;v14<-a1;v2<-a2;v8<-a1;v13<-a0;v9<-a0;v4<-a2;v19<-a0;v29<-a2;v17<-a1;v23<-a0;' 2 | asm = ''' 3 | ''' 4 | 5 | def do_subst(asgn): 6 | asgns = asgn.split(';') 7 | subst = {} 8 | for s in asgns: 9 | if s == '': 10 | continue 11 | x, y = s.split('<-') 12 | subst[x] = y 13 | head = '' 14 | for k, v in subst.items(): 15 | head += f'#define {k} {v}\n' 16 | print(head + asm) 17 | 18 | do_subst(assignment) -------------------------------------------------------------------------------- /test-ext.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env fish 2 | 3 | for file in test/test_src/*.mbt 4 | echo "Testing $file" 5 | moon run src/bin/main.mbt -- --ext -notc $file -o out.mjs && node js_rt/runtime.mjs out.mjs 6 | echo \n 7 | end 8 | 9 | for file in test/longer-cases/*.mbt 10 | echo "Testing $file" 11 | moon run src/bin/main.mbt -- --ext -notc $file -o out.mjs && node js_rt/runtime.mjs out.mjs 12 | echo \n 13 | end -------------------------------------------------------------------------------- /test-js.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env fish 2 | 3 | for file in test/test_src/*.mbt 4 | echo "Testing $file" 5 | moon run src/bin/main.mbt -- --js -notc $file -o out.mjs && node js_rt/runtime.mjs out.mjs 6 | echo \n 7 | end 8 | 9 | for file in test/longer-cases/*.mbt 10 | echo "Testing $file" 11 | moon run src/bin/main.mbt -- --js -notc $file -o out.mjs && node js_rt/runtime.mjs out.mjs 12 | echo \n 13 | end 14 | -------------------------------------------------------------------------------- /test-rv.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env fish 2 | 3 | for file in test/test_src/*.mbt 4 | echo "Testing $file" 5 | rm -f out 6 | rm -f out.S 7 | moon run src/bin/main.mbt -- --end-stage riscv -notc $file -o out.S 8 | zig build-exe -target riscv64-linux -femit-bin=out riscv_rt/zig-out/lib/libmincaml.a out.S -O Debug -fno-strip -mcpu=baseline_rv64 9 | ./rvlinux -n out 10 | echo \n 11 | end -------------------------------------------------------------------------------- /test-wasm.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | for file in test/test_src/*.mbt 4 | do 5 | echo "Testing $file" 6 | moon run src/bin/main.mbt -q -g -- --end-stage wasm $file -o $file.wat && 7 | wasm-tools parse $file.wat -o $file.wasm && 8 | wasm-tools validate $file.wasm && 9 | node wasm_rt/runtime.mjs $file.wasm 10 | 11 | ret=$? 12 | if [ $ret -eq 0 ]; then 13 | echo 14 | echo "Test $file succeeded" 15 | rm -rf $file.wat $file.wasm 16 | else 17 | echo "Test $file failed" 18 | fi 19 | done -------------------------------------------------------------------------------- /test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env fish 2 | 3 | for file in test/test_src/*.mbt 4 | echo "Testing $file" 5 | moon run src/bin/main.mbt -- --end-stage riscv $file --use-xthead 6 | echo \n 7 | end 8 | 9 | for file in test/longer-cases/*.mbt 10 | echo "Testing $file" 11 | moon run src/bin/main.mbt -- --end-stage riscv $file --use-xthead 12 | echo \n 13 | end 14 | 15 | for file in test/more-tests/*.mbt 16 | echo "Testing $file" 17 | moon run src/bin/main.mbt -- --end-stage riscv $file --use-xthead 18 | echo \n 19 | end -------------------------------------------------------------------------------- /test/.gitignore: -------------------------------------------------------------------------------- 1 | rv64_failed_tests/ -------------------------------------------------------------------------------- /test/longer-cases/bf.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {read_ch_until_newline_or_eof.1: @hashset.of([]), skip.161: @hashset.of([prog.137, i.140]), lp.229: @hashset.of([aux.176, ptr.152, prog.137, read_ch_until_newline_or_eof.1, skip.161, cells.157, next_pc.160, i.140, pc.177]), aux.176: @hashset.of([ptr.152, prog.137, read_ch_until_newline_or_eof.1, skip.161, cells.157, next_pc.160, i.140]), read_prog.138: @hashset.of([read_ch_until_newline_or_eof.1, prog.137]), main.134: @hashset.of([read_ch_until_newline_or_eof.1])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/fannkuch-redux.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {init_arr.298: @hashset.of([arr.297]), copy_perm.330: @hashset.of([perm.308, arr.297]), init_count.340: @hashset.of([r.326, count.310]), flip_loop.374: @hashset.of([k.367, t.373, perm.308]), do_flip.366: @hashset.of([perm.308, flips.313]), move_perm1_forward.461: @hashset.of([arr.297, r.326]), go_loop.444: @hashset.of([t.443, go.440, _263, arr.297, r.326, count.310]), compute.325: @hashset.of([max_flips.316, nperm.322, _263, perm.308, arr.297, flips.313, count.310, check_sum.319]), main.262: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/generic.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {next.133: @hashset.of([arr.36]), do.112: @hashset.of([arr.36]), next.144: @hashset.of([arr.66]), do.130: @hashset.of([arr.66]), main.33: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/isort.ans: -------------------------------------------------------------------------------- 1 | 279 513 1094 1338 2111 3159 3803 5325 5362 6227 6278 7522 7621 7980 7994 8340 8431 8692 8741 9002 9326 9727 9791 10002 10151 12165 12551 13121 13213 13492 13670 14472 16587 17802 19854 20999 21356 21565 21639 22272 22657 22790 23151 24205 24473 24484 25086 27221 27325 28249 28680 28886 28919 29317 32049 32437 32713 34363 34774 34887 35741 36128 36882 38400 38549 39928 40388 40492 42269 42566 43151 44067 44154 44417 44561 45509 45950 46488 46748 46770 46966 47310 47321 47353 47761 48348 49063 50111 52181 53890 54499 59169 60468 60656 60924 61209 61983 62141 64433 65299 -------------------------------------------------------------------------------- /test/longer-cases/isort.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {aux.98: @hashset.of([arr.88, n.86]), insert.114: @hashset.of([]), aux.132: @hashset.of([arr.88, n.86, insert.114]), aux.138: @hashset.of([arr.88, n.86]), main.85: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/isort.in: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Mini-Moonbit-Machine/mmm/91d7d32f313cf25e834c86a948d228e18329213a/test/longer-cases/isort.in -------------------------------------------------------------------------------- /test/longer-cases/iter.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {next.80: @hashset.of([arr.36]), do.77: @hashset.of([arr.36]), main.33: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/julia.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {calc_pixel.7: @hashset.of([c_im.6, limit_sq.2, c_re.5]), main_loop.30: @hashset.of([c_im.6, limit_sq.2, calc_pixel.7, c_re.5]), print_loop.68: @hashset.of([]), main.94: @hashset.of([limit_sq.2, print_loop.68, c_im.6, calc_pixel.7, c_re.5, main_loop.30])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/julia.in: -------------------------------------------------------------------------------- 1 | 50 2 | -------------------------------------------------------------------------------- /test/longer-cases/mem-fib.ans: -------------------------------------------------------------------------------- 1 | 102334155 2 | -------------------------------------------------------------------------------- /test/longer-cases/mem-fib.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {memed.51: @hashset.of([cache.50]), main.33: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/mem-fib.in: -------------------------------------------------------------------------------- 1 | 40 2 | -------------------------------------------------------------------------------- /test/longer-cases/phi.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {rec.1: @hashset.of([]), main.8: @hashset.of([rec.1])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf.txt: -------------------------------------------------------------------------------- 1 | let rec rec.1: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.1, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.8: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.1, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.8, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec rec.1: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.1, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.8: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.1, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.8, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec rec.1: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.1, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.8: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.1, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.8, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec rec.1: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.1, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.8: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.1, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.8, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec rec.13: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.13, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.14: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.13, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.14, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec rec.13: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.13, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.14: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.13, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.14, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec rec.13: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.13, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.14: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.13, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.14, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec rec.13: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.13, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.14: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.13, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.14, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec rec.13: Unit = (x.3: Int, y.5: Int) { 2 | if (x.3 == y.5) then { 3 | let _6: Int = Int(1) 4 | let _7: Int = Add(x.3, _6) 5 | Apply(rec.13, [y.5, _7, ]) 6 | } else { 7 | Unit 8 | } 9 | } 10 | let rec main.14: Unit = () { 11 | let _9: Int = Int(0) 12 | let _10: Int = Int(0) 13 | let _12: Unit = Apply(rec.13, [_9, _10, ]) 14 | Unit 15 | } 16 | Apply(main.14, []) 17 | -------------------------------------------------------------------------------- /test/longer-cases/phi.mbt: -------------------------------------------------------------------------------- 1 | fn rec(x: Int, y: Int) -> Unit { 2 | if x == y { 3 | rec(y, x + 1) 4 | } else { 5 | () 6 | } 7 | }; 8 | 9 | fn main { 10 | rec(0, 0); 11 | }; -------------------------------------------------------------------------------- /test/longer-cases/phi.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec rec: (x: Int, y: Int) -> Unit { 2 | if (Eq(Var("x"), Var("y"))) then { 3 | Apply(Var("rec"), [Var("y"), Prim(Var("x"), Int(1), Add, kind=None), ]) 4 | } else { 5 | Unit 6 | } 7 | } 8 | let rec main: () -> Var(None) { 9 | let _: Var(None) = Apply(Var("rec"), [Int(0), Int(0), ]) 10 | Unit 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/longer-cases/phi.typer.txt: -------------------------------------------------------------------------------- 1 | let rec rec: (x: Int, y: Int) -> Unit { 2 | if (Eq(Var("x"), Var("y"))) then { 3 | Apply[](Var("rec"), [Var("y"), Prim(Var("x"), Int(1), Add, kind=Some(Int)), ]) 4 | } else { 5 | Unit 6 | } 7 | } 8 | let rec main: () -> Unit { 9 | let _: Unit = Apply[](Var("rec"), [Int(0), Int(0), ]) 10 | Unit 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/longer-cases/phi.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec rec: (x: Int, y: Int) -> Unit { 2 | if (Eq(Var("x"), Var("y"))) then { 3 | Apply[](Var("rec"), [Var("y"), Prim(Var("x"), Int(1), Add, kind=Some(Int)), ]) 4 | } else { 5 | Unit 6 | } 7 | } 8 | let rec main: () -> Unit { 9 | let _: Unit = Apply[](Var("rec"), [Int(0), Int(0), ]) 10 | Unit 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/longer-cases/quicksort-std.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {swap.1: @hashset.of([]), output.14: @hashset.of([]), g.259: @hashset.of([swap.1, low.214, arr.212]), f.274: @hashset.of([swap.1, low.214, arr.212, g.259, high.216]), sort_2.305: @hashset.of([swaps.286, swap.1, arr.212]), sort_3.318: @hashset.of([swaps.286, sort_2.305, swap.1, arr.212]), aux.356: @hashset.of([pivot.350, partitioned.355, swap.1, i.352, arr.212, high.216]), quick_sort.210: @hashset.of([swap.1]), input.243: @hashset.of([arr.242, len.240]), main.239: @hashset.of([swap.1, output.14, quick_sort.210])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/quicksort.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {swap.1: @hashset.of([]), l.115: @hashset.of([arr.61, i.114, pivot.110, swap.1, high.65]), quicksort.59: @hashset.of([swap.1]), input.79: @hashset.of([len.76, arr.78]), output.97: @hashset.of([len.76, arr.78]), main.75: @hashset.of([swap.1, quicksort.59])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/stream.ans: -------------------------------------------------------------------------------- 1 | 503100 2 | -------------------------------------------------------------------------------- /test/longer-cases/stream.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {fold.84: @hashset.of([]), aux.193: @hashset.of([_122, state.144, _125, _128, _131, state.157]), aux.208: @hashset.of([state.157, state.144, _125, _134, _128, _131, aux.193, _122]), add.221: @hashset.of([]), main.120: @hashset.of([fold.84])} 2 | -------------------------------------------------------------------------------- /test/longer-cases/stream.in: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Mini-Moonbit-Machine/mmm/91d7d32f313cf25e834c86a948d228e18329213a/test/longer-cases/stream.in -------------------------------------------------------------------------------- /test/more-tests/nbody.ans: -------------------------------------------------------------------------------- 1 | -169075164 2 | 183976403 -------------------------------------------------------------------------------- /test/more-tests/nbody.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {loop_j.185: @hashset.of([by.160, bx.158, bz.162, bm.170, e.150, bodies.146]), loop_i.151: @hashset.of([e.150, bodies.146]), energy.144: @hashset.of([]), loop_i.471: @hashset.of([bodies.412, pz.470, px.464, py.467]), loop_j.545: @hashset.of([bx.538, bodies.412, i.533, bm.544, bz.540, bvz.543, _440, bvx.541, by.539, bvy.542]), loop_i.532: @hashset.of([_440, bodies.412]), update_axis.602: @hashset.of([_440, bodies.412]), loop_i.437: @hashset.of([iters.436, bodies.412]), main.337: @hashset.of([solar_mass.4, energy.144])} 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt2_after_fo.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt2_after_jtbl.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt2_after_lvn.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_dfe_0.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_dfe_1.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_dfe_2.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_licm.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_lvn.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_o2f.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_splitted_0.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_splitted_1.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_splitted_2.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.core_opt_after_tre.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {} 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.knf_to_core.txt: -------------------------------------------------------------------------------- 1 | # name conventions used in the core ir: 2 | # - functions: f 3 | # - blocks: b 4 | # - instructions: % 5 | # - memory: m 6 | # - free variables: ^ 7 | # - function parameters: $f 8 | # - block parameters: $b. 9 | .core 10 | 11 | -------------------------------------------------------------------------------- /test/more-tests/prelude.mbt: -------------------------------------------------------------------------------- 1 | 2 | // fn float_of_int(x: Int) -> Double { 3 | // x.to_double() 4 | // }; 5 | 6 | // fn int_of_float(x: Double) -> Int { 7 | // x.to_int() 8 | // }; 9 | 10 | // fn print_int(x: Int) -> Unit { 11 | // println(x) 12 | // }; 13 | 14 | // fn sqrt(x: Double) -> Double { 15 | // x.sqrt() 16 | // }; 17 | 18 | // fn print_char(x: Int) -> Unit { 19 | // if x == 10 { 20 | // } else { 21 | // println(Char::from_int(x)) 22 | // } 23 | // }; -------------------------------------------------------------------------------- /test/more-tests/prelude.resolved.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.typer.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/prelude.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | Unit 2 | -------------------------------------------------------------------------------- /test/more-tests/simd-large.ans: -------------------------------------------------------------------------------- 1 | 1566450 2 | 1566450 -------------------------------------------------------------------------------- /test/more-tests/simd-large.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {fma_mixed.67: @hashset.of([]), init_vi_arr.126: @hashset.of([vi_arr.125]), init_vd_arr.155: @hashset.of([vd_arr.154]), stress.316: @hashset.of([fma_mixed.67, vd_arr.154, vi_arr.125]), main.118: @hashset.of([fma_mixed.67])} 2 | -------------------------------------------------------------------------------- /test/test_src/.gitignore: -------------------------------------------------------------------------------- 1 | *.res 2 | *.s 3 | -------------------------------------------------------------------------------- /test/test_src/ack.ans: -------------------------------------------------------------------------------- 1 | 2045 2 | -------------------------------------------------------------------------------- /test/test_src/ack.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {ack.1: @hashset.of([]), main.17: @hashset.of([ack.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/ack.mbt: -------------------------------------------------------------------------------- 1 | fn ack(x : Int, y : Int) -> Int { 2 | if x <= 0 { 3 | y + 1 4 | } else { 5 | if y <= 0 { 6 | ack(x - 1, 1) 7 | } else { 8 | ack(x - 1, ack(x, y - 1)) 9 | } 10 | } 11 | }; 12 | 13 | fn main { 14 | print_int(ack(3,8)) 15 | }; -------------------------------------------------------------------------------- /test/test_src/adder-double.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.8: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/adder-double.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.8: Unit = () { 2 | let _9: Double = Double(2.14) 3 | let rec adder.14: Double = (y.15: Int) { 4 | let _16: Double = ExtApply(minimbt_float_of_int, [y.15, ]) 5 | FAdd(_9, _16) 6 | } 7 | let _11: Int = Int(1) 8 | let _12: Double = Apply(adder.14, [_11, ]) 9 | let _13: Int = ExtApply(minimbt_int_of_float, [_12, ]) 10 | ExtApply(minimbt_print_int, [_13, ]) 11 | } 12 | Apply(main.8, []) 13 | -------------------------------------------------------------------------------- /test/test_src/adder-double.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.8: Unit = () { 2 | let _9: Double = Double(2.14) 3 | let _11: Int = Int(1) 4 | let _17: Double = ExtApply(minimbt_float_of_int, [_11, ]) 5 | let _12: Double = FAdd(_9, _17) 6 | let _13: Int = ExtApply(minimbt_int_of_float, [_12, ]) 7 | ExtApply(minimbt_print_int, [_13, ]) 8 | } 9 | Apply(main.8, []) 10 | -------------------------------------------------------------------------------- /test/test_src/adder-double.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.8: Unit = () { 2 | let _9: Double = Double(2.14) 3 | let _11: Int = Int(1) 4 | let _17: Double = ExtApply(minimbt_float_of_int, [_11, ]) 5 | let _12: Double = FAdd(_9, _17) 6 | let _13: Int = ExtApply(minimbt_int_of_float, [_12, ]) 7 | ExtApply(minimbt_print_int, [_13, ]) 8 | } 9 | Apply(main.8, []) 10 | -------------------------------------------------------------------------------- /test/test_src/adder-double.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _9: Double = Double(2.14) 3 | let _11: Int = Int(1) 4 | let _17: Double = ExtApply(minimbt_float_of_int, [_11, ]) 5 | let _12: Double = FAdd(_9, _17) 6 | let _13: Int = ExtApply(minimbt_int_of_float, [_12, ]) 7 | ExtApply(minimbt_print_int, [_13, ]) 8 | } 9 | Apply(main.18, []) 10 | -------------------------------------------------------------------------------- /test/test_src/adder-double.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _9: Double = Double(2.14) 3 | let _11: Int = Int(1) 4 | let _17: Double = ExtApply(minimbt_float_of_int, [_11, ]) 5 | let _12: Double = FAdd(_9, _17) 6 | let _13: Int = ExtApply(minimbt_int_of_float, [_12, ]) 7 | ExtApply(minimbt_print_int, [_13, ]) 8 | } 9 | Apply(main.18, []) 10 | -------------------------------------------------------------------------------- /test/test_src/adder-double.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _9: Double = Double(2.14) 3 | let _11: Int = Int(1) 4 | let _17: Double = ExtApply(minimbt_float_of_int, [_11, ]) 5 | let _12: Double = FAdd(_9, _17) 6 | let _13: Int = ExtApply(minimbt_int_of_float, [_12, ]) 7 | ExtApply(minimbt_print_int, [_13, ]) 8 | } 9 | Apply(main.18, []) 10 | -------------------------------------------------------------------------------- /test/test_src/adder-double.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _9: Double = Double(2.14) 3 | let _11: Int = Int(1) 4 | let _17: Double = ExtApply(minimbt_float_of_int, [_11, ]) 5 | let _12: Double = FAdd(_9, _17) 6 | let _13: Int = ExtApply(minimbt_int_of_float, [_12, ]) 7 | ExtApply(minimbt_print_int, [_13, ]) 8 | } 9 | Apply(main.18, []) 10 | -------------------------------------------------------------------------------- /test/test_src/adder-double.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _9: Double = Double(2.14) 3 | let _11: Int = Int(1) 4 | let _17: Double = ExtApply(minimbt_float_of_int, [_11, ]) 5 | let _12: Double = FAdd(_9, _17) 6 | let _13: Int = ExtApply(minimbt_int_of_float, [_12, ]) 7 | ExtApply(minimbt_print_int, [_13, ]) 8 | } 9 | Apply(main.18, []) 10 | -------------------------------------------------------------------------------- /test/test_src/adder-double.mbt: -------------------------------------------------------------------------------- 1 | fn make_adder(x: Double) -> (Int) -> Double { 2 | fn adder(y: Int) -> Double { 3 | x + float_of_int(y) 4 | }; 5 | adder 6 | }; 7 | 8 | fn main { 9 | let add = make_adder(2.14); 10 | print_int(int_of_float(add(1))) 11 | }; -------------------------------------------------------------------------------- /test/test_src/adder-double.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Double) -> (Int) -> Double { 2 | let rec adder: (y: Int) -> Double { 3 | Var("x") + App(Var("float_of_int"), targs=None, [Var("y")]) 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Var(None) { 8 | let add: Var(None) = Apply(Var("make_adder"), [Double(2.14), ]) 9 | Apply(Var("print_int"), [App(Var("int_of_float"), targs=None, [App(Var("add"), targs=None, [Int(1)])]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/adder-double.typer.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Double) -> (Int) -> Double { 2 | let rec adder: (y: Int) -> Double { 3 | Var("x") + App(Var("float_of_int"), targs=Some([]), [Var("y")]) 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Unit { 8 | let add: (Int) -> Double = Apply[](Var("make_adder"), [Double(2.14), ]) 9 | Apply[](Var("print_int"), [App(Var("int_of_float"), targs=Some([]), [App(Var("add"), targs=Some([]), [Int(1)])]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/adder-double.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Double) -> (Int) -> Double { 2 | let rec adder: (y: Int) -> Double { 3 | Var("x") + App(Var("float_of_int"), targs=Some([]), [Var("y")]) 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Unit { 8 | let add: (Int) -> Double = Apply[](Var("make_adder"), [Double(2.14), ]) 9 | Apply[](Var("print_int"), [App(Var("int_of_float"), targs=Some([]), [App(Var("add"), targs=Some([]), [Int(1)])]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/adder.ans: -------------------------------------------------------------------------------- 1 | 10 2 | -------------------------------------------------------------------------------- /test/test_src/adder.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.7: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/adder.knf.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder.1: (Int) -> Int = (x.3: Int) { 2 | let rec adder.4: Int = (y.6: Int) { 3 | Add(x.3, y.6) 4 | } 5 | Var(adder.4) 6 | } 7 | let rec main.7: Unit = () { 8 | let _8: Int = Int(3) 9 | let _9: (Int) -> Int = Apply(make_adder.1, [_8, ]) 10 | let _10: Int = Int(7) 11 | let _11: Int = Apply(_9, [_10, ]) 12 | ExtApply(minimbt_print_int, [_11, ]) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/adder.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Int = Int(3) 3 | let rec adder.12: Int = (y.13: Int) { 4 | Add(_8, y.13) 5 | } 6 | let _10: Int = Int(7) 7 | let _11: Int = Apply(adder.12, [_10, ]) 8 | ExtApply(minimbt_print_int, [_11, ]) 9 | } 10 | Apply(main.7, []) 11 | -------------------------------------------------------------------------------- /test/test_src/adder.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Int = Int(3) 3 | let _10: Int = Int(7) 4 | let _11: Int = Int(10) 5 | ExtApply(minimbt_print_int, [_11, ]) 6 | } 7 | Apply(main.7, []) 8 | -------------------------------------------------------------------------------- /test/test_src/adder.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Int = Int(3) 3 | let _10: Int = Int(7) 4 | let _11: Int = Int(10) 5 | ExtApply(minimbt_print_int, [_11, ]) 6 | } 7 | Apply(main.7, []) 8 | -------------------------------------------------------------------------------- /test/test_src/adder.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(3) 3 | let _10: Int = Int(7) 4 | let _11: Int = Int(10) 5 | ExtApply(minimbt_print_int, [_11, ]) 6 | } 7 | Apply(main.12, []) 8 | -------------------------------------------------------------------------------- /test/test_src/adder.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(3) 3 | let _10: Int = Int(7) 4 | let _11: Int = Int(10) 5 | ExtApply(minimbt_print_int, [_11, ]) 6 | } 7 | Apply(main.12, []) 8 | -------------------------------------------------------------------------------- /test/test_src/adder.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(3) 3 | let _10: Int = Int(7) 4 | let _11: Int = Int(10) 5 | ExtApply(minimbt_print_int, [_11, ]) 6 | } 7 | Apply(main.12, []) 8 | -------------------------------------------------------------------------------- /test/test_src/adder.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(3) 3 | let _10: Int = Int(7) 4 | let _11: Int = Int(10) 5 | ExtApply(minimbt_print_int, [_11, ]) 6 | } 7 | Apply(main.12, []) 8 | -------------------------------------------------------------------------------- /test/test_src/adder.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(3) 3 | let _10: Int = Int(7) 4 | let _11: Int = Int(10) 5 | ExtApply(minimbt_print_int, [_11, ]) 6 | } 7 | Apply(main.12, []) 8 | -------------------------------------------------------------------------------- /test/test_src/adder.mbt: -------------------------------------------------------------------------------- 1 | fn make_adder(x: Int) -> (Int) -> Int { 2 | fn adder(y: Int) -> Int { 3 | x + y 4 | }; 5 | adder 6 | }; 7 | 8 | fn main { 9 | print_int((make_adder(3))(7)) 10 | }; -------------------------------------------------------------------------------- /test/test_src/adder.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Int) -> (Int) -> Int { 2 | let rec adder: (y: Int) -> Int { 3 | Var("x") + Var("y") 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Var(None) { 8 | Apply(Var("print_int"), [App(App(Var("make_adder"), targs=None, [Int(3)]), targs=None, [Int(7)]), ]) 9 | } 10 | Unit 11 | -------------------------------------------------------------------------------- /test/test_src/adder.typer.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Int) -> (Int) -> Int { 2 | let rec adder: (y: Int) -> Int { 3 | Var("x") + Var("y") 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Unit { 8 | Apply[](Var("print_int"), [App(App(Var("make_adder"), targs=Some([]), [Int(3)]), targs=None, [Int(7)]), ]) 9 | } 10 | Unit 11 | -------------------------------------------------------------------------------- /test/test_src/adder.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Int) -> (Int) -> Int { 2 | let rec adder: (y: Int) -> Int { 3 | Var("x") + Var("y") 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Unit { 8 | Apply[](Var("print_int"), [App(App(Var("make_adder"), targs=Some([]), [Int(3)]), targs=None, [Int(7)]), ]) 9 | } 10 | Unit 11 | -------------------------------------------------------------------------------- /test/test_src/adder2.ans: -------------------------------------------------------------------------------- 1 | 35 2 | -------------------------------------------------------------------------------- /test/test_src/adder2.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.7: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/adder2.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Int = Int(2) 3 | let rec adder.17: Int = (y.18: Int) { 4 | Add(_8, y.18) 5 | } 6 | let _10: Int = Int(3) 7 | let rec adder.19: Int = (y.20: Int) { 8 | Add(_10, y.20) 9 | } 10 | let _12: Int = Int(10) 11 | let _13: Int = Apply(adder.17, [_12, ]) 12 | let _14: Int = Int(20) 13 | let _15: Int = Apply(adder.19, [_14, ]) 14 | let _16: Int = Add(_13, _15) 15 | ExtApply(minimbt_print_int, [_16, ]) 16 | } 17 | Apply(main.7, []) 18 | -------------------------------------------------------------------------------- /test/test_src/adder2.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Int = Int(2) 3 | let _10: Int = Int(3) 4 | let _12: Int = Int(10) 5 | let _13: Int = Int(12) 6 | let _14: Int = Int(20) 7 | let _15: Int = Int(23) 8 | let _16: Int = Int(35) 9 | ExtApply(minimbt_print_int, [_16, ]) 10 | } 11 | Apply(main.7, []) 12 | -------------------------------------------------------------------------------- /test/test_src/adder2.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Int = Int(2) 3 | let _10: Int = Int(3) 4 | let _12: Int = Int(10) 5 | let _13: Int = Int(12) 6 | let _14: Int = Int(20) 7 | let _15: Int = Int(23) 8 | let _16: Int = Int(35) 9 | ExtApply(minimbt_print_int, [_16, ]) 10 | } 11 | Apply(main.7, []) 12 | -------------------------------------------------------------------------------- /test/test_src/adder2.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.17: Unit = () { 2 | let _8: Int = Int(2) 3 | let _10: Int = Int(3) 4 | let _12: Int = Int(10) 5 | let _13: Int = Int(12) 6 | let _14: Int = Int(20) 7 | let _15: Int = Int(23) 8 | let _16: Int = Int(35) 9 | ExtApply(minimbt_print_int, [_16, ]) 10 | } 11 | Apply(main.17, []) 12 | -------------------------------------------------------------------------------- /test/test_src/adder2.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.17: Unit = () { 2 | let _8: Int = Int(2) 3 | let _10: Int = Int(3) 4 | let _12: Int = Int(10) 5 | let _13: Int = Int(12) 6 | let _14: Int = Int(20) 7 | let _15: Int = Int(23) 8 | let _16: Int = Int(35) 9 | ExtApply(minimbt_print_int, [_16, ]) 10 | } 11 | Apply(main.17, []) 12 | -------------------------------------------------------------------------------- /test/test_src/adder2.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.17: Unit = () { 2 | let _8: Int = Int(2) 3 | let _10: Int = Int(3) 4 | let _12: Int = Int(10) 5 | let _13: Int = Int(12) 6 | let _14: Int = Int(20) 7 | let _15: Int = Int(23) 8 | let _16: Int = Int(35) 9 | ExtApply(minimbt_print_int, [_16, ]) 10 | } 11 | Apply(main.17, []) 12 | -------------------------------------------------------------------------------- /test/test_src/adder2.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.17: Unit = () { 2 | let _8: Int = Int(2) 3 | let _10: Int = Int(3) 4 | let _12: Int = Int(10) 5 | let _13: Int = Int(12) 6 | let _14: Int = Int(20) 7 | let _15: Int = Int(23) 8 | let _16: Int = Int(35) 9 | ExtApply(minimbt_print_int, [_16, ]) 10 | } 11 | Apply(main.17, []) 12 | -------------------------------------------------------------------------------- /test/test_src/adder2.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.17: Unit = () { 2 | let _8: Int = Int(2) 3 | let _10: Int = Int(3) 4 | let _12: Int = Int(10) 5 | let _13: Int = Int(12) 6 | let _14: Int = Int(20) 7 | let _15: Int = Int(23) 8 | let _16: Int = Int(35) 9 | ExtApply(minimbt_print_int, [_16, ]) 10 | } 11 | Apply(main.17, []) 12 | -------------------------------------------------------------------------------- /test/test_src/adder2.mbt: -------------------------------------------------------------------------------- 1 | fn make_adder(x: Int) -> (Int) -> Int { 2 | fn adder(y: Int) -> Int { 3 | x + y 4 | }; 5 | adder 6 | }; 7 | 8 | fn main { 9 | let add2 = make_adder(2); 10 | let add3 = make_adder(3); 11 | print_int(add2(10) + add3(20)) 12 | }; -------------------------------------------------------------------------------- /test/test_src/adder2.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Int) -> (Int) -> Int { 2 | let rec adder: (y: Int) -> Int { 3 | Var("x") + Var("y") 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Var(None) { 8 | let add2: Var(None) = Apply(Var("make_adder"), [Int(2), ]) 9 | let add3: Var(None) = Apply(Var("make_adder"), [Int(3), ]) 10 | Apply(Var("print_int"), [Prim(App(Var("add2"), targs=None, [Int(10)]), App(Var("add3"), targs=None, [Int(20)]), Add, kind=None), ]) 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/test_src/adder2.typer.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Int) -> (Int) -> Int { 2 | let rec adder: (y: Int) -> Int { 3 | Var("x") + Var("y") 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Unit { 8 | let add2: (Int) -> Int = Apply[](Var("make_adder"), [Int(2), ]) 9 | let add3: (Int) -> Int = Apply[](Var("make_adder"), [Int(3), ]) 10 | Apply[](Var("print_int"), [Prim(App(Var("add2"), targs=Some([]), [Int(10)]), App(Var("add3"), targs=Some([]), [Int(20)]), Add, kind=Some(Int)), ]) 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/test_src/adder2.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec make_adder: (x: Int) -> (Int) -> Int { 2 | let rec adder: (y: Int) -> Int { 3 | Var("x") + Var("y") 4 | } 5 | Var(adder) 6 | } 7 | let rec main: () -> Unit { 8 | let add2: (Int) -> Int = Apply[](Var("make_adder"), [Int(2), ]) 9 | let add3: (Int) -> Int = Apply[](Var("make_adder"), [Int(3), ]) 10 | Apply[](Var("print_int"), [Prim(App(Var("add2"), targs=Some([]), [Int(10)]), App(Var("add3"), targs=Some([]), [Int(20)]), Add, kind=Some(Int)), ]) 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.ans: -------------------------------------------------------------------------------- 1 | 912 2 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.8: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf.txt: -------------------------------------------------------------------------------- 1 | let rec f.1: Int = (x.3: Int) { 2 | let _4: Int = Int(123) 3 | Add(x.3, _4) 4 | } 5 | let rec g.5: (Int) -> Int = (y.7: Int) { 6 | Var(f.1) 7 | } 8 | let rec main.8: Unit = () { 9 | let _9: Int = Int(456) 10 | let _10: (Int) -> Int = Apply(g.5, [_9, ]) 11 | let _11: Int = Int(789) 12 | let _12: Int = Apply(_10, [_11, ]) 13 | ExtApply(minimbt_print_int, [_12, ]) 14 | } 15 | Apply(main.8, []) 16 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec f.1: Int = (x.3: Int) { 2 | let _4: Int = Int(123) 3 | Add(x.3, _4) 4 | } 5 | let rec main.8: Unit = () { 6 | let _9: Int = Int(456) 7 | let _11: Int = Int(789) 8 | let _12: Int = Apply(f.1, [_11, ]) 9 | ExtApply(minimbt_print_int, [_12, ]) 10 | } 11 | Apply(main.8, []) 12 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.8: Unit = () { 2 | let _9: Int = Int(456) 3 | let _11: Int = Int(789) 4 | let _13: Int = Int(123) 5 | let _12: Int = Int(912) 6 | ExtApply(minimbt_print_int, [_12, ]) 7 | } 8 | Apply(main.8, []) 9 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.8: Unit = () { 2 | let _9: Int = Int(456) 3 | let _11: Int = Int(789) 4 | let _13: Int = Int(123) 5 | let _12: Int = Int(912) 6 | ExtApply(minimbt_print_int, [_12, ]) 7 | } 8 | Apply(main.8, []) 9 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _9: Int = Int(456) 3 | let _11: Int = Int(789) 4 | let _13: Int = Int(123) 5 | let _12: Int = Int(912) 6 | ExtApply(minimbt_print_int, [_12, ]) 7 | } 8 | Apply(main.14, []) 9 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _9: Int = Int(456) 3 | let _11: Int = Int(789) 4 | let _13: Int = Int(123) 5 | let _12: Int = Int(912) 6 | ExtApply(minimbt_print_int, [_12, ]) 7 | } 8 | Apply(main.14, []) 9 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _9: Int = Int(456) 3 | let _11: Int = Int(789) 4 | let _13: Int = Int(123) 5 | let _12: Int = Int(912) 6 | ExtApply(minimbt_print_int, [_12, ]) 7 | } 8 | Apply(main.14, []) 9 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _9: Int = Int(456) 3 | let _11: Int = Int(789) 4 | let _13: Int = Int(123) 5 | let _12: Int = Int(912) 6 | ExtApply(minimbt_print_int, [_12, ]) 7 | } 8 | Apply(main.14, []) 9 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _9: Int = Int(456) 3 | let _11: Int = Int(789) 4 | let _13: Int = Int(123) 5 | let _12: Int = Int(912) 6 | ExtApply(minimbt_print_int, [_12, ]) 7 | } 8 | Apply(main.14, []) 9 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.mbt: -------------------------------------------------------------------------------- 1 | fn f(x: Int) -> Int { 2 | x + 123 3 | }; 4 | 5 | fn g(y: Int) -> (Int) -> Int { 6 | f 7 | }; 8 | 9 | fn main { 10 | print_int((g(456))(789)) 11 | }; -------------------------------------------------------------------------------- /test/test_src/cls-bug.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: (x: Int) -> Int { 2 | Var("x") + Int(123) 3 | } 4 | let rec g: (y: Int) -> (Int) -> Int { 5 | Var(f) 6 | } 7 | let rec main: () -> Var(None) { 8 | Apply(Var("print_int"), [App(App(Var("g"), targs=None, [Int(456)]), targs=None, [Int(789)]), ]) 9 | } 10 | Unit 11 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: (x: Int) -> Int { 2 | Var("x") + Int(123) 3 | } 4 | let rec g: (y: Int) -> (Int) -> Int { 5 | Var(f) 6 | } 7 | let rec main: () -> Unit { 8 | Apply[](Var("print_int"), [App(App(Var("g"), targs=Some([]), [Int(456)]), targs=None, [Int(789)]), ]) 9 | } 10 | Unit 11 | -------------------------------------------------------------------------------- /test/test_src/cls-bug.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec f: (x: Int) -> Int { 2 | Var("x") + Int(123) 3 | } 4 | let rec g: (y: Int) -> (Int) -> Int { 5 | Var(f) 6 | } 7 | let rec main: () -> Unit { 8 | Apply[](Var("print_int"), [App(App(Var("g"), targs=Some([]), [Int(456)]), targs=None, [Int(789)]), ]) 9 | } 10 | Unit 11 | -------------------------------------------------------------------------------- /test/test_src/cls-bug2.ans: -------------------------------------------------------------------------------- 1 | 9876543210 2 | -------------------------------------------------------------------------------- /test/test_src/cls-bug2.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {f.1: @hashset.of([]), main.12: @hashset.of([f.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/cls-bug2.mbt: -------------------------------------------------------------------------------- 1 | fn f(n: Int) -> Unit { 2 | if not(0 <= n) { 3 | () 4 | } else { 5 | let t1 = print_int(n); 6 | let a = Array::make(1, f); 7 | let a0 = a[0]; 8 | a0(n - 1) 9 | } 10 | }; 11 | 12 | fn main{ 13 | f(9) 14 | }; -------------------------------------------------------------------------------- /test/test_src/cls-bug2.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: (n: Int) -> Unit { 2 | if (Not(LE(Int(0), Var("n")))) then { 3 | Unit 4 | } else { 5 | let t1: Var(None) = Apply(Var("print_int"), [Var("n"), ]) 6 | let a: Var(None) = Array::make(Int(1), Var("f")) 7 | let a0: Var(None) = Get Var("a")[Int(0)] 8 | Apply(Var("a0"), [Prim(Var("n"), Int(1), Sub, kind=None), ]) 9 | } 10 | } 11 | let rec main: () -> Var(None) { 12 | Apply(Var("f"), [Int(9), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/cls-bug2.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: (n: Int) -> Unit { 2 | if (Not(LE(Int(0), Var("n")))) then { 3 | Unit 4 | } else { 5 | let t1: Unit = Apply[](Var("print_int"), [Var("n"), ]) 6 | let a: Array[(Int) -> Unit] = Array::make(Int(1), Var("f")) 7 | let a0: (Int) -> Unit = Get Var("a")[Int(0)] 8 | Apply[](Var("a0"), [Prim(Var("n"), Int(1), Sub, kind=Some(Int)), ]) 9 | } 10 | } 11 | let rec main: () -> Unit { 12 | Apply[](Var("f"), [Int(9), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/cls-bug2.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec f: (n: Int) -> Unit { 2 | if (Not(LE(Int(0), Var("n")))) then { 3 | Unit 4 | } else { 5 | let t1: Unit = Apply[](Var("print_int"), [Var("n"), ]) 6 | let a: Array[(Int) -> Unit] = Array::make(Int(1), Var("f")) 7 | let a0: (Int) -> Unit = Get Var("a")[Int(0)] 8 | Apply[](Var("a0"), [Prim(Var("n"), Int(1), Sub, kind=Some(Int)), ]) 9 | } 10 | } 11 | let rec main: () -> Unit { 12 | Apply[](Var("f"), [Int(9), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/cls-rec-bug.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {f.1: @hashset.of([]), main.8: @hashset.of([f.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/cls-rec-bug.knf.txt: -------------------------------------------------------------------------------- 1 | let rec f.1: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (_4 <= x.3) then { 4 | let _5: Int = Int(-1) 5 | let _7: Int = Apply(f.1, [_5, ]) 6 | Int(1) 7 | } else { 8 | Int(-1) 9 | } 10 | } 11 | let rec main.8: Unit = () { 12 | let _9: Int = Int(10) 13 | let _10: Int = Apply(f.1, [_9, ]) 14 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 15 | let _13: Int = Int(-10) 16 | let _14: Int = Apply(f.1, [_13, ]) 17 | let _16: Unit = ExtApply(minimbt_print_int, [_14, ]) 18 | Unit 19 | } 20 | Apply(main.8, []) 21 | -------------------------------------------------------------------------------- /test/test_src/cls-rec-bug.mbt: -------------------------------------------------------------------------------- 1 | fn f(x: Int) -> Int { 2 | if 0 <= x { 3 | let _ = f(-1); 4 | 1 5 | } else { 6 | -1 7 | } 8 | }; 9 | 10 | fn main { 11 | print_int(f(10)); 12 | print_int(f(-10)); 13 | () 14 | }; 15 | -------------------------------------------------------------------------------- /test/test_src/cls-rec-bug.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: (x: Int) -> Int { 2 | if (LE(Int(0), Var("x"))) then { 3 | let _: Var(None) = Apply(Var("f"), [Neg(Int(1), kind=None), ]) 4 | Int(1) 5 | } else { 6 | Neg(Int(1)) 7 | } 8 | } 9 | let rec main: () -> Var(None) { 10 | let _: Var(None) = Apply(Var("print_int"), [App(Var("f"), targs=None, [Int(10)]), ]) 11 | let _: Var(None) = Apply(Var("print_int"), [App(Var("f"), targs=None, [Neg(Int(10), kind=None)]), ]) 12 | Unit 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/cls-rec-bug.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: (x: Int) -> Int { 2 | if (LE(Int(0), Var("x"))) then { 3 | let _: Int = Apply[](Var("f"), [Neg(Int(1), kind=Some(Int)), ]) 4 | Int(1) 5 | } else { 6 | Neg(Int(1)) 7 | } 8 | } 9 | let rec main: () -> Unit { 10 | let _: Unit = Apply[](Var("print_int"), [App(Var("f"), targs=Some([]), [Int(10)]), ]) 11 | let _: Unit = Apply[](Var("print_int"), [App(Var("f"), targs=Some([]), [Neg(Int(10), kind=Some(Int))]), ]) 12 | Unit 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/cls-rec-bug.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec f: (x: Int) -> Int { 2 | if (LE(Int(0), Var("x"))) then { 3 | let _: Int = Apply[](Var("f"), [Neg(Int(1), kind=Some(Int)), ]) 4 | Int(1) 5 | } else { 6 | Neg(Int(1)) 7 | } 8 | } 9 | let rec main: () -> Unit { 10 | let _: Unit = Apply[](Var("print_int"), [App(Var("f"), targs=Some([]), [Int(10)]), ]) 11 | let _: Unit = Apply[](Var("print_int"), [App(Var("f"), targs=Some([]), [Neg(Int(10), kind=Some(Int))]), ]) 12 | Unit 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.ans: -------------------------------------------------------------------------------- 1 | 120 2 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {f.2: @hashset.of([]), main.9: @hashset.of([f.2])} 2 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf.txt: -------------------------------------------------------------------------------- 1 | let x.1: Int = Int(10) 2 | let rec f.2: Int = (y.4: Int) { 3 | let _5: Int = Int(0) 4 | if (y.4 == _5) then { 5 | Int(0) 6 | } else { 7 | let _6: Int = Int(1) 8 | let _7: Int = Sub(y.4, _6) 9 | let _8: Int = Apply(f.2, [_7, ]) 10 | Add(x.1, _8) 11 | } 12 | } 13 | let rec main.9: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.2, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.9, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec f.2: Int = (y.4: Int) { 2 | let _5: Int = Int(0) 3 | if (y.4 == _5) then { 4 | Int(0) 5 | } else { 6 | let _6: Int = Int(1) 7 | let _7: Int = Sub(y.4, _6) 8 | let _8: Int = Apply(f.2, [_7, ]) 9 | let _12: Int = Int(10) 10 | Add(_12, _8) 11 | } 12 | } 13 | let rec main.9: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.2, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.9, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec f.2: Int = (y.4: Int) { 2 | let _5: Int = Int(0) 3 | if (y.4 == _5) then { 4 | Int(0) 5 | } else { 6 | let _6: Int = Int(1) 7 | let _7: Int = Sub(y.4, _6) 8 | let _8: Int = Apply(f.2, [_7, ]) 9 | let _12: Int = Int(10) 10 | Add(_12, _8) 11 | } 12 | } 13 | let rec main.9: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.2, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.9, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec f.2: Int = (y.4: Int) { 2 | let _5: Int = Int(0) 3 | if (y.4 == _5) then { 4 | Int(0) 5 | } else { 6 | let _6: Int = Int(1) 7 | let _7: Int = Sub(y.4, _6) 8 | let _8: Int = Apply(f.2, [_7, ]) 9 | let _12: Int = Int(10) 10 | Add(_12, _8) 11 | } 12 | } 13 | let rec main.9: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.2, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.9, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec f.13: Int = (y.4: Int) { 2 | let _5: Int = Int(0) 3 | if (y.4 == _5) then { 4 | Int(0) 5 | } else { 6 | let _6: Int = Int(1) 7 | let _7: Int = Sub(y.4, _6) 8 | let _8: Int = Apply(f.13, [_7, ]) 9 | let _12: Int = Int(10) 10 | Add(_12, _8) 11 | } 12 | } 13 | let rec main.14: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.13, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.14, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec f.13: Int = (y.4: Int) { 2 | let _5: Int = Int(0) 3 | if (y.4 == _5) then { 4 | Int(0) 5 | } else { 6 | let _6: Int = Int(1) 7 | let _7: Int = Sub(y.4, _6) 8 | let _8: Int = Apply(f.13, [_7, ]) 9 | let _12: Int = Int(10) 10 | Add(_12, _8) 11 | } 12 | } 13 | let rec main.14: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.13, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.14, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec f.13: Int = (y.4: Int) { 2 | let _5: Int = Int(0) 3 | if (y.4 == _5) then { 4 | Int(0) 5 | } else { 6 | let _6: Int = Int(1) 7 | let _7: Int = Sub(y.4, _6) 8 | let _8: Int = Apply(f.13, [_7, ]) 9 | let _12: Int = Int(10) 10 | Add(_12, _8) 11 | } 12 | } 13 | let rec main.14: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.13, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.14, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec f.13: Int = (y.4: Int) { 2 | let _5: Int = Int(0) 3 | if (y.4 == _5) then { 4 | Int(0) 5 | } else { 6 | let _6: Int = Int(1) 7 | let _7: Int = Sub(y.4, _6) 8 | let _8: Int = Apply(f.13, [_7, ]) 9 | let _12: Int = Int(10) 10 | Add(_12, _8) 11 | } 12 | } 13 | let rec main.14: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.13, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.14, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec f.13: Int = (y.4: Int) { 2 | let _5: Int = Int(0) 3 | if (y.4 == _5) then { 4 | Int(0) 5 | } else { 6 | let _6: Int = Int(1) 7 | let _7: Int = Sub(y.4, _6) 8 | let _8: Int = Apply(f.13, [_7, ]) 9 | let _12: Int = Int(10) 10 | Add(_12, _8) 11 | } 12 | } 13 | let rec main.14: Unit = () { 14 | let _10: Int = Int(12) 15 | let _11: Int = Apply(f.13, [_10, ]) 16 | ExtApply(minimbt_print_int, [_11, ]) 17 | } 18 | Apply(main.14, []) 19 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.mbt: -------------------------------------------------------------------------------- 1 | let x: Int = 10; 2 | 3 | fn f(y: Int) -> Int { 4 | if y == 0 { 5 | 0 6 | } else { 7 | x + f(y - 1) 8 | } 9 | }; 10 | 11 | fn main { 12 | print_int(f(12)) 13 | }; 14 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.resolved.txt: -------------------------------------------------------------------------------- 1 | let x: Int = Int(10) 2 | let rec f: (y: Int) -> Int { 3 | if (Eq(Var("y"), Int(0))) then { 4 | Int(0) 5 | } else { 6 | Var("x") + App(Var("f"), targs=None, [Prim(Var("y"), Int(1), Sub, kind=None)]) 7 | } 8 | } 9 | let rec main: () -> Var(None) { 10 | Apply(Var("print_int"), [App(Var("f"), targs=None, [Int(12)]), ]) 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.typer.txt: -------------------------------------------------------------------------------- 1 | let x: Int = Int(10) 2 | let rec f: (y: Int) -> Int { 3 | if (Eq(Var("y"), Int(0))) then { 4 | Int(0) 5 | } else { 6 | Var("x") + App(Var("f"), targs=Some([]), [Prim(Var("y"), Int(1), Sub, kind=Some(Int))]) 7 | } 8 | } 9 | let rec main: () -> Unit { 10 | Apply[](Var("print_int"), [App(Var("f"), targs=Some([]), [Int(12)]), ]) 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/test_src/cls-rec.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let x: Int = Int(10) 2 | let rec f: (y: Int) -> Int { 3 | if (Eq(Var("y"), Int(0))) then { 4 | Int(0) 5 | } else { 6 | Var("x") + App(Var("f"), targs=Some([]), [Prim(Var("y"), Int(1), Sub, kind=Some(Int))]) 7 | } 8 | } 9 | let rec main: () -> Unit { 10 | Apply[](Var("print_int"), [App(Var("f"), targs=Some([]), [Int(12)]), ]) 11 | } 12 | Unit 13 | -------------------------------------------------------------------------------- /test/test_src/cls-reg-bug.ans: -------------------------------------------------------------------------------- 1 | 55 2 | 3 | -------------------------------------------------------------------------------- /test/test_src/cls-reg-bug.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {g.63: @hashset.of([v1.53, v6.58, v3.55, v4.56, v2.54, v8.60, v9.61, v7.59, v5.57, v10.62]), main.39: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/cls-reg-bug.mbt: -------------------------------------------------------------------------------- 1 | fn h(p: (Int, Int, Int, Int, Int, Int, Int, Int, Int, Int)) -> Int { 2 | let (v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) = p; 3 | fn g(z: Int) -> Int { 4 | let r = v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10; 5 | if not(z <= 0) { 6 | r 7 | } else { 8 | g(-z) 9 | } 10 | }; 11 | g(1) 12 | }; 13 | 14 | fn main { 15 | let t1 = print_int(h((1, 2, 3, 4, 5, 6, 7, 8, 9, 10))); 16 | () 17 | }; -------------------------------------------------------------------------------- /test/test_src/critical_edge.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.6: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf.txt: -------------------------------------------------------------------------------- 1 | let rec f.1: Int = () { 2 | let _2: Int = Int(6) 3 | let _3: Int = Int(0) 4 | if (_2 <= _3) then { 5 | Int(1) 6 | } else { 7 | let _4: Int = Int(6) 8 | let _5: Int = Int(10) 9 | if (_4 <= _5) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | } 16 | let rec main.6: Unit = () { 17 | let _7: Int = Apply(f.1, []) 18 | ExtApply(minimbt_print_int, [_7, ]) 19 | } 20 | Apply(main.6, []) 21 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.6: Unit = () { 2 | let _8: Int = Int(6) 3 | let _9: Int = Int(0) 4 | let _7: Int = if (_8 <= _9) then { 5 | Int(1) 6 | } else { 7 | let _10: Int = Int(6) 8 | let _11: Int = Int(10) 9 | if (_10 <= _11) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | ExtApply(minimbt_print_int, [_7, ]) 16 | } 17 | Apply(main.6, []) 18 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.6: Unit = () { 2 | let _8: Int = Int(6) 3 | let _9: Int = Int(0) 4 | let _7: Int = if (_8 <= _9) then { 5 | Int(1) 6 | } else { 7 | let _10: Int = Int(6) 8 | let _11: Int = Int(10) 9 | if (_10 <= _11) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | ExtApply(minimbt_print_int, [_7, ]) 16 | } 17 | Apply(main.6, []) 18 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.6: Unit = () { 2 | let _8: Int = Int(6) 3 | let _9: Int = Int(0) 4 | let _7: Int = if (_8 <= _9) then { 5 | Int(1) 6 | } else { 7 | let _10: Int = Int(6) 8 | let _11: Int = Int(10) 9 | if (_10 <= _11) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | ExtApply(minimbt_print_int, [_7, ]) 16 | } 17 | Apply(main.6, []) 18 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(6) 3 | let _9: Int = Int(0) 4 | let _7: Int = if (_8 <= _9) then { 5 | Int(1) 6 | } else { 7 | let _10: Int = Int(6) 8 | let _11: Int = Int(10) 9 | if (_10 <= _11) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | ExtApply(minimbt_print_int, [_7, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(6) 3 | let _9: Int = Int(0) 4 | let _7: Int = if (_8 <= _9) then { 5 | Int(1) 6 | } else { 7 | let _10: Int = Int(6) 8 | let _11: Int = Int(10) 9 | if (_10 <= _11) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | ExtApply(minimbt_print_int, [_7, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(6) 3 | let _9: Int = Int(0) 4 | let _7: Int = if (_8 <= _9) then { 5 | Int(1) 6 | } else { 7 | let _10: Int = Int(6) 8 | let _11: Int = Int(10) 9 | if (_10 <= _11) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | ExtApply(minimbt_print_int, [_7, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(6) 3 | let _9: Int = Int(0) 4 | let _7: Int = if (_8 <= _9) then { 5 | Int(1) 6 | } else { 7 | let _10: Int = Int(6) 8 | let _11: Int = Int(10) 9 | if (_10 <= _11) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | ExtApply(minimbt_print_int, [_7, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _8: Int = Int(6) 3 | let _9: Int = Int(0) 4 | let _7: Int = if (_8 <= _9) then { 5 | Int(1) 6 | } else { 7 | let _10: Int = Int(6) 8 | let _11: Int = Int(10) 9 | if (_10 <= _11) then { 10 | Int(2) 11 | } else { 12 | Int(3) 13 | } 14 | } 15 | ExtApply(minimbt_print_int, [_7, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.mbt: -------------------------------------------------------------------------------- 1 | fn f() -> Int { 2 | if 6 <= 0 { 3 | 1 4 | } else { 5 | if 6 <= 10 { 6 | 2 7 | } else { 8 | 3 9 | } 10 | } 11 | }; 12 | 13 | fn main { 14 | print_int(f()) 15 | }; -------------------------------------------------------------------------------- /test/test_src/critical_edge.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: () -> Int { 2 | if (LE(Int(6), Int(0))) then { 3 | Int(1) 4 | } else { 5 | if (LE(Int(6), Int(10))) then { 6 | Int(2) 7 | } else { 8 | Int(3) 9 | } 10 | } 11 | } 12 | let rec main: () -> Var(None) { 13 | Apply(Var("print_int"), [App(Var("f"), targs=None, []), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: () -> Int { 2 | if (LE(Int(6), Int(0))) then { 3 | Int(1) 4 | } else { 5 | if (LE(Int(6), Int(10))) then { 6 | Int(2) 7 | } else { 8 | Int(3) 9 | } 10 | } 11 | } 12 | let rec main: () -> Unit { 13 | Apply[](Var("print_int"), [App(Var("f"), targs=Some([]), []), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/critical_edge.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec f: () -> Int { 2 | if (LE(Int(6), Int(0))) then { 3 | Int(1) 4 | } else { 5 | if (LE(Int(6), Int(10))) then { 6 | Int(2) 7 | } else { 8 | Int(3) 9 | } 10 | } 11 | } 12 | let rec main: () -> Unit { 13 | Apply[](Var("print_int"), [App(Var("f"), targs=Some([]), []), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/debug.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {g.45: @hashset.of([]), f.9: @hashset.of([]), main.19: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/debug.freg.txt: -------------------------------------------------------------------------------- 1 | graph G { 2 | graph [label="float interference graph of main.56"]; 3 | comment = "" 4 | comment = "" 5 | } 6 | 7 | -------------------------------------------------------------------------------- /test/test_src/debug.mbt: -------------------------------------------------------------------------------- 1 | fn useless(x: Int) -> Int { 2 | let y = x; 3 | 10-1 4 | }; 5 | fn dummy(x: Int) -> Int { 6 | x 7 | }; 8 | 9 | fn f(x: Int) -> Int { 10 | fn g(y: Int) -> Int { 11 | x 12 | }; 13 | if true { 14 | f(1) 15 | } else { 16 | g(2) 17 | } 18 | }; 19 | 20 | fn main { 21 | () 22 | } 23 | -------------------------------------------------------------------------------- /test/test_src/debug.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec useless: (x: Int) -> Int { 2 | let y: Var(None) = Var(x) 3 | Int(10) - Int(1) 4 | } 5 | let rec dummy: (x: Int) -> Int { 6 | Var(x) 7 | } 8 | let rec f: (x: Int) -> Int { 9 | let rec g: (y: Int) -> Int { 10 | Var(x) 11 | } 12 | if (Bool(true)) then { 13 | Apply(Var("f"), [Int(1), ]) 14 | } else { 15 | Apply(Var("g"), [Int(2), ]) 16 | } 17 | } 18 | let rec main: () -> Var(None) { 19 | Unit 20 | } 21 | Unit 22 | -------------------------------------------------------------------------------- /test/test_src/debug.typer.txt: -------------------------------------------------------------------------------- 1 | let rec useless: (x: Int) -> Int { 2 | let y: Int = Var(x) 3 | Int(10) - Int(1) 4 | } 5 | let rec dummy: (x: Int) -> Int { 6 | Var(x) 7 | } 8 | let rec f: (x: Int) -> Int { 9 | let rec g: (y: Int) -> Int { 10 | Var(x) 11 | } 12 | if (Bool(true)) then { 13 | Apply[](Var("f"), [Int(1), ]) 14 | } else { 15 | Apply[](Var("g"), [Int(2), ]) 16 | } 17 | } 18 | let rec main: () -> Unit { 19 | Unit 20 | } 21 | Unit 22 | -------------------------------------------------------------------------------- /test/test_src/debug.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec useless: (x: Int) -> Int { 2 | let y: Int = Var(x) 3 | Int(10) - Int(1) 4 | } 5 | let rec dummy: (x: Int) -> Int { 6 | Var(x) 7 | } 8 | let rec f: (x: Int) -> Int { 9 | let rec g: (y: Int) -> Int { 10 | Var(x) 11 | } 12 | if (Bool(true)) then { 13 | Apply[](Var("f"), [Int(1), ]) 14 | } else { 15 | Apply[](Var("g"), [Int(2), ]) 16 | } 17 | } 18 | let rec main: () -> Unit { 19 | Unit 20 | } 21 | Unit 22 | -------------------------------------------------------------------------------- /test/test_src/debug.xreg.txt: -------------------------------------------------------------------------------- 1 | graph G { 2 | graph [label="integer interference graph of main.56"]; 3 | r0 [label="zero", color=blue]; 4 | r1 [label="a0", color=blue]; 5 | comment = "0:zero-> 1:a0" 6 | comment = "" 7 | } 8 | 9 | -------------------------------------------------------------------------------- /test/test_src/even-odd.ans: -------------------------------------------------------------------------------- 1 | 456 2 | -------------------------------------------------------------------------------- /test/test_src/even-odd.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {odd.6: @hashset.of([even.3]), even.3: @hashset.of([]), main.21: @hashset.of([even.3])} 2 | -------------------------------------------------------------------------------- /test/test_src/even-odd.mbt: -------------------------------------------------------------------------------- 1 | let t: Int = 123; 2 | let f: Int = 456; 3 | 4 | fn even(x: Int) -> Int { 5 | fn odd(x: Int) -> Int { 6 | if 0 <= x { 7 | if x == 0 { 8 | f 9 | } else { 10 | even(x - 1) 11 | } 12 | } else { 13 | even(x + 1) 14 | } 15 | }; 16 | if 0 <= x { 17 | if x == 0 { 18 | t 19 | } else { 20 | odd(x - 1) 21 | } 22 | } else { 23 | odd(x + 1) 24 | } 25 | }; 26 | 27 | fn main { 28 | print_int(even(789)) 29 | }; 30 | -------------------------------------------------------------------------------- /test/test_src/feature_test.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.1: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/feature_test.mbt: -------------------------------------------------------------------------------- 1 | fn main { 2 | print_int(int_of_float(1.0 + 2.0)); 3 | print_int(int_of_float(1.0 - 2.0)); 4 | print_int(int_of_float(1.0 * 2.0)); 5 | print_int(int_of_float(1.0 / 2.0)); 6 | if 1.0 <= 2.0 { 7 | print_int(1) 8 | } else { 9 | print_int(0) 10 | }; 11 | if 1.0 == 1.0 { 12 | print_int(1) 13 | } else { 14 | print_int(0) 15 | } 16 | } -------------------------------------------------------------------------------- /test/test_src/fib.ans: -------------------------------------------------------------------------------- 1 | 832040 2 | -------------------------------------------------------------------------------- /test/test_src/fib.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {fib.1: @hashset.of([]), main.11: @hashset.of([fib.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/fib.knf.txt: -------------------------------------------------------------------------------- 1 | let rec fib.1: Int = (n.3: Int) { 2 | let _4: Int = Int(1) 3 | if (n.3 <= _4) then { 4 | Var(n.3) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(n.3, _5) 8 | let _7: Int = Apply(fib.1, [_6, ]) 9 | let _8: Int = Int(2) 10 | let _9: Int = Sub(n.3, _8) 11 | let _10: Int = Apply(fib.1, [_9, ]) 12 | Add(_7, _10) 13 | } 14 | } 15 | let rec main.11: Unit = () { 16 | let _12: Int = Int(30) 17 | let _13: Int = Apply(fib.1, [_12, ]) 18 | ExtApply(minimbt_print_int, [_13, ]) 19 | } 20 | Apply(main.11, []) 21 | -------------------------------------------------------------------------------- /test/test_src/fib.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec fib.1: Int = (n.3: Int) { 2 | let _4: Int = Int(1) 3 | if (n.3 <= _4) then { 4 | Var(n.3) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(n.3, _5) 8 | let _7: Int = Apply(fib.1, [_6, ]) 9 | let _8: Int = Int(2) 10 | let _9: Int = Sub(n.3, _8) 11 | let _10: Int = Apply(fib.1, [_9, ]) 12 | Add(_7, _10) 13 | } 14 | } 15 | let rec main.11: Unit = () { 16 | let _12: Int = Int(30) 17 | let _13: Int = Apply(fib.1, [_12, ]) 18 | ExtApply(minimbt_print_int, [_13, ]) 19 | } 20 | Apply(main.11, []) 21 | -------------------------------------------------------------------------------- /test/test_src/fib.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec fib.1: Int = (n.3: Int) { 2 | let _4: Int = Int(1) 3 | if (n.3 <= _4) then { 4 | Var(n.3) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(n.3, _5) 8 | let _7: Int = Apply(fib.1, [_6, ]) 9 | let _8: Int = Int(2) 10 | let _9: Int = Sub(n.3, _8) 11 | let _10: Int = Apply(fib.1, [_9, ]) 12 | Add(_7, _10) 13 | } 14 | } 15 | let rec main.11: Unit = () { 16 | let _12: Int = Int(30) 17 | let _13: Int = Apply(fib.1, [_12, ]) 18 | ExtApply(minimbt_print_int, [_13, ]) 19 | } 20 | Apply(main.11, []) 21 | -------------------------------------------------------------------------------- /test/test_src/fib.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec fib.1: Int = (n.3: Int) { 2 | let _4: Int = Int(1) 3 | if (n.3 <= _4) then { 4 | Var(n.3) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(n.3, _5) 8 | let _7: Int = Apply(fib.1, [_6, ]) 9 | let _8: Int = Int(2) 10 | let _9: Int = Sub(n.3, _8) 11 | let _10: Int = Apply(fib.1, [_9, ]) 12 | Add(_7, _10) 13 | } 14 | } 15 | let rec main.11: Unit = () { 16 | let _12: Int = Int(30) 17 | let _13: Int = Apply(fib.1, [_12, ]) 18 | ExtApply(minimbt_print_int, [_13, ]) 19 | } 20 | Apply(main.11, []) 21 | -------------------------------------------------------------------------------- /test/test_src/fib.mbt: -------------------------------------------------------------------------------- 1 | fn fib(n: Int) -> Int { 2 | if n <= 1 { 3 | n 4 | } else { 5 | fib(n - 1) + fib(n - 2) 6 | } 7 | }; 8 | 9 | fn main { 10 | print_int(fib(30)) 11 | }; 12 | -------------------------------------------------------------------------------- /test/test_src/fib.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec fib: (n: Int) -> Int { 2 | if (LE(Var("n"), Int(1))) then { 3 | Var(n) 4 | } else { 5 | App(Var("fib"), targs=None, [Prim(Var("n"), Int(1), Sub, kind=None)]) + App(Var("fib"), targs=None, [Prim(Var("n"), Int(2), Sub, kind=None)]) 6 | } 7 | } 8 | let rec main: () -> Var(None) { 9 | Apply(Var("print_int"), [App(Var("fib"), targs=None, [Int(30)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/fib.typer.txt: -------------------------------------------------------------------------------- 1 | let rec fib: (n: Int) -> Int { 2 | if (LE(Var("n"), Int(1))) then { 3 | Var(n) 4 | } else { 5 | App(Var("fib"), targs=Some([]), [Prim(Var("n"), Int(1), Sub, kind=Some(Int))]) + App(Var("fib"), targs=Some([]), [Prim(Var("n"), Int(2), Sub, kind=Some(Int))]) 6 | } 7 | } 8 | let rec main: () -> Unit { 9 | Apply[](Var("print_int"), [App(Var("fib"), targs=Some([]), [Int(30)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/fib.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec fib: (n: Int) -> Int { 2 | if (LE(Var("n"), Int(1))) then { 3 | Var(n) 4 | } else { 5 | App(Var("fib"), targs=Some([]), [Prim(Var("n"), Int(1), Sub, kind=Some(Int))]) + App(Var("fib"), targs=Some([]), [Prim(Var("n"), Int(2), Sub, kind=Some(Int))]) 6 | } 7 | } 8 | let rec main: () -> Unit { 9 | Apply[](Var("print_int"), [App(Var("fib"), targs=Some([]), [Int(30)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/float.ans: -------------------------------------------------------------------------------- 1 | -44604263 2 | -------------------------------------------------------------------------------- /test/test_src/float.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.1: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/float.mbt: -------------------------------------------------------------------------------- 1 | fn main { 2 | print_int( 3 | int_of_float( 4 | (sin(cos(sqrt(abs_float(-12.3)))) + 4.5 - 6.7 * 8.9 / 1.23456789) * float_of_int(1000000) 5 | ) 6 | ) 7 | }; -------------------------------------------------------------------------------- /test/test_src/float.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Var(None) { 2 | Apply(Var("print_int"), [App(Var("int_of_float"), targs=None, [Prim(Prim(Prim(App(Var("sin"), targs=None, [App(Var("cos"), targs=None, [App(Var("sqrt"), targs=None, [App(Var("abs_float"), targs=None, [Neg(Double(12.3), kind=None)])])])]), Double(4.5), Add, kind=None), Prim(Prim(Double(6.7), Double(8.9), Mul, kind=None), Double(1.23456789), Div, kind=None), Sub, kind=None), App(Var("float_of_int"), targs=None, [Int(1000000)]), Mul, kind=None)]), ]) 3 | } 4 | Unit 5 | -------------------------------------------------------------------------------- /test/test_src/float.typer.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | Apply[](Var("print_int"), [App(Var("int_of_float"), targs=Some([]), [Prim(Prim(Prim(App(Var("sin"), targs=Some([]), [App(Var("cos"), targs=Some([]), [App(Var("sqrt"), targs=Some([]), [App(Var("abs_float"), targs=Some([]), [Neg(Double(12.3), kind=Some(Double))])])])]), Double(4.5), Add, kind=Some(Double)), Prim(Prim(Double(6.7), Double(8.9), Mul, kind=Some(Double)), Double(1.23456789), Div, kind=Some(Double)), Sub, kind=Some(Double)), App(Var("float_of_int"), targs=Some([]), [Int(1000000)]), Mul, kind=Some(Double))]), ]) 3 | } 4 | Unit 5 | -------------------------------------------------------------------------------- /test/test_src/funcomp.ans: -------------------------------------------------------------------------------- 1 | 247 2 | -------------------------------------------------------------------------------- /test/test_src/funcomp.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.21: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/funcomp.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.21: Unit = () { 2 | let _24: Int = Int(123) 3 | let _37: Int = Int(1) 4 | let _36: Int = Int(124) 5 | let _38: Int = Int(248) 6 | let _39: Int = Int(1) 7 | let _25: Int = Int(247) 8 | ExtApply(minimbt_print_int, [_25, ]) 9 | } 10 | Apply(main.21, []) 11 | -------------------------------------------------------------------------------- /test/test_src/funcomp.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.21: Unit = () { 2 | let _24: Int = Int(123) 3 | let _37: Int = Int(1) 4 | let _36: Int = Int(124) 5 | let _38: Int = Int(248) 6 | let _39: Int = Int(1) 7 | let _25: Int = Int(247) 8 | ExtApply(minimbt_print_int, [_25, ]) 9 | } 10 | Apply(main.21, []) 11 | -------------------------------------------------------------------------------- /test/test_src/funcomp.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.40: Unit = () { 2 | let _24: Int = Int(123) 3 | let _37: Int = Int(1) 4 | let _36: Int = Int(124) 5 | let _38: Int = Int(248) 6 | let _39: Int = Int(1) 7 | let _25: Int = Int(247) 8 | ExtApply(minimbt_print_int, [_25, ]) 9 | } 10 | Apply(main.40, []) 11 | -------------------------------------------------------------------------------- /test/test_src/funcomp.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.40: Unit = () { 2 | let _24: Int = Int(123) 3 | let _37: Int = Int(1) 4 | let _36: Int = Int(124) 5 | let _38: Int = Int(248) 6 | let _39: Int = Int(1) 7 | let _25: Int = Int(247) 8 | ExtApply(minimbt_print_int, [_25, ]) 9 | } 10 | Apply(main.40, []) 11 | -------------------------------------------------------------------------------- /test/test_src/funcomp.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.40: Unit = () { 2 | let _24: Int = Int(123) 3 | let _37: Int = Int(1) 4 | let _36: Int = Int(124) 5 | let _38: Int = Int(248) 6 | let _39: Int = Int(1) 7 | let _25: Int = Int(247) 8 | ExtApply(minimbt_print_int, [_25, ]) 9 | } 10 | Apply(main.40, []) 11 | -------------------------------------------------------------------------------- /test/test_src/funcomp.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.40: Unit = () { 2 | let _24: Int = Int(123) 3 | let _37: Int = Int(1) 4 | let _36: Int = Int(124) 5 | let _38: Int = Int(248) 6 | let _39: Int = Int(1) 7 | let _25: Int = Int(247) 8 | ExtApply(minimbt_print_int, [_25, ]) 9 | } 10 | Apply(main.40, []) 11 | -------------------------------------------------------------------------------- /test/test_src/funcomp.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.40: Unit = () { 2 | let _24: Int = Int(123) 3 | let _37: Int = Int(1) 4 | let _36: Int = Int(124) 5 | let _38: Int = Int(248) 6 | let _39: Int = Int(1) 7 | let _25: Int = Int(247) 8 | ExtApply(minimbt_print_int, [_25, ]) 9 | } 10 | Apply(main.40, []) 11 | -------------------------------------------------------------------------------- /test/test_src/funcomp.mbt: -------------------------------------------------------------------------------- 1 | fn compose(f: (Int) -> Int, g: (Int) -> Int) -> (Int) -> Int { 2 | fn composed(x: Int) -> Int { 3 | g(f(x)) 4 | }; 5 | composed 6 | }; 7 | 8 | fn dbl(x: Int) -> Int { 9 | x + x 10 | }; 11 | 12 | fn inc(x: Int) -> Int { 13 | x + 1 14 | }; 15 | 16 | fn dec(x: Int) -> Int { 17 | x - 1 18 | }; 19 | 20 | fn main { 21 | let h = compose(inc, compose(dbl, dec)); 22 | print_int(h(123)) 23 | }; -------------------------------------------------------------------------------- /test/test_src/gcd.ans: -------------------------------------------------------------------------------- 1 | 2700 2 | -------------------------------------------------------------------------------- /test/test_src/gcd.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {gcd.1: @hashset.of([]), main.9: @hashset.of([gcd.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/gcd.mbt: -------------------------------------------------------------------------------- 1 | fn gcd(m: Int, n: Int) -> Int { 2 | if m == 0 { 3 | n 4 | } else { 5 | if m <= n { 6 | gcd(m, n - m) 7 | } else { 8 | gcd(n, m - n) 9 | } 10 | } 11 | }; 12 | 13 | fn main { 14 | print_int(gcd(21600, 337500)) 15 | }; 16 | -------------------------------------------------------------------------------- /test/test_src/gcd.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec gcd: (m: Int, n: Int) -> Int { 2 | if (Eq(Var("m"), Int(0))) then { 3 | Var(n) 4 | } else { 5 | if (LE(Var("m"), Var("n"))) then { 6 | Apply(Var("gcd"), [Var("m"), Prim(Var("n"), Var("m"), Sub, kind=None), ]) 7 | } else { 8 | Apply(Var("gcd"), [Var("n"), Prim(Var("m"), Var("n"), Sub, kind=None), ]) 9 | } 10 | } 11 | } 12 | let rec main: () -> Var(None) { 13 | Apply(Var("print_int"), [App(Var("gcd"), targs=None, [Int(21600), Int(337500)]), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/gcd.typer.txt: -------------------------------------------------------------------------------- 1 | let rec gcd: (m: Int, n: Int) -> Int { 2 | if (Eq(Var("m"), Int(0))) then { 3 | Var(n) 4 | } else { 5 | if (LE(Var("m"), Var("n"))) then { 6 | Apply[](Var("gcd"), [Var("m"), Prim(Var("n"), Var("m"), Sub, kind=Some(Int)), ]) 7 | } else { 8 | Apply[](Var("gcd"), [Var("n"), Prim(Var("m"), Var("n"), Sub, kind=Some(Int)), ]) 9 | } 10 | } 11 | } 12 | let rec main: () -> Unit { 13 | Apply[](Var("print_int"), [App(Var("gcd"), targs=Some([]), [Int(21600), Int(337500)]), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/gcd.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec gcd: (m: Int, n: Int) -> Int { 2 | if (Eq(Var("m"), Int(0))) then { 3 | Var(n) 4 | } else { 5 | if (LE(Var("m"), Var("n"))) then { 6 | Apply[](Var("gcd"), [Var("m"), Prim(Var("n"), Var("m"), Sub, kind=Some(Int)), ]) 7 | } else { 8 | Apply[](Var("gcd"), [Var("n"), Prim(Var("m"), Var("n"), Sub, kind=Some(Int)), ]) 9 | } 10 | } 11 | } 12 | let rec main: () -> Unit { 13 | Apply[](Var("print_int"), [App(Var("gcd"), targs=Some([]), [Int(21600), Int(337500)]), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/global_spill.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {print.39: @hashset.of([dummy.32]), main.64: @hashset.of([print.39, dummy.32])} 2 | -------------------------------------------------------------------------------- /test/test_src/htuple.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.16: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/id.ans: -------------------------------------------------------------------------------- 1 | 1001 2 | -------------------------------------------------------------------------------- /test/test_src/id.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.4: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/id.knf.txt: -------------------------------------------------------------------------------- 1 | let rec f.1: T = (x.3: T) { 2 | Var(x.3) 3 | } 4 | let rec main.4: Unit = () { 5 | let _5: Int = Int(1000) 6 | let _6: T = Apply(f.1, [_5, ]) 7 | let _8: Unit = ExtApply(minimbt_print_int, [_6, ]) 8 | let _9: Double = Double(1000) 9 | let _10: T = Apply(f.1, [_9, ]) 10 | let _11: Int = ExtApply(minimbt_int_of_float, [_10, ]) 11 | ExtApply(minimbt_print_int, [_11, ]) 12 | } 13 | Apply(main.4, []) 14 | -------------------------------------------------------------------------------- /test/test_src/id.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.4: Unit = () { 2 | let _5: Int = Int(1000) 3 | let _8: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | let _9: Double = Double(1000) 5 | let _11: Int = ExtApply(minimbt_int_of_float, [_9, ]) 6 | ExtApply(minimbt_print_int, [_11, ]) 7 | } 8 | Apply(main.4, []) 9 | -------------------------------------------------------------------------------- /test/test_src/id.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.4: Unit = () { 2 | let _5: Int = Int(1000) 3 | let _8: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | let _9: Double = Double(1000) 5 | let _11: Int = ExtApply(minimbt_int_of_float, [_9, ]) 6 | ExtApply(minimbt_print_int, [_11, ]) 7 | } 8 | Apply(main.4, []) 9 | -------------------------------------------------------------------------------- /test/test_src/id.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.4: Unit = () { 2 | let _5: Int = Int(1000) 3 | let _8: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | let _9: Double = Double(1000) 5 | let _11: Int = ExtApply(minimbt_int_of_float, [_9, ]) 6 | ExtApply(minimbt_print_int, [_11, ]) 7 | } 8 | Apply(main.4, []) 9 | -------------------------------------------------------------------------------- /test/test_src/id.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _5: Int = Int(1000) 3 | let _8: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | let _9: Double = Double(1000) 5 | let _11: Int = ExtApply(minimbt_int_of_float, [_9, ]) 6 | ExtApply(minimbt_print_int, [_11, ]) 7 | } 8 | Apply(main.12, []) 9 | -------------------------------------------------------------------------------- /test/test_src/id.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _5: Int = Int(1000) 3 | let _8: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | let _9: Double = Double(1000) 5 | let _11: Int = ExtApply(minimbt_int_of_float, [_9, ]) 6 | ExtApply(minimbt_print_int, [_11, ]) 7 | } 8 | Apply(main.12, []) 9 | -------------------------------------------------------------------------------- /test/test_src/id.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _5: Int = Int(1000) 3 | let _8: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | let _9: Double = Double(1000) 5 | let _11: Int = ExtApply(minimbt_int_of_float, [_9, ]) 6 | ExtApply(minimbt_print_int, [_11, ]) 7 | } 8 | Apply(main.12, []) 9 | -------------------------------------------------------------------------------- /test/test_src/id.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _5: Int = Int(1000) 3 | let _8: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | let _9: Double = Double(1000) 5 | let _11: Int = ExtApply(minimbt_int_of_float, [_9, ]) 6 | ExtApply(minimbt_print_int, [_11, ]) 7 | } 8 | Apply(main.12, []) 9 | -------------------------------------------------------------------------------- /test/test_src/id.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.12: Unit = () { 2 | let _5: Int = Int(1000) 3 | let _8: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | let _9: Double = Double(1000) 5 | let _11: Int = ExtApply(minimbt_int_of_float, [_9, ]) 6 | ExtApply(minimbt_print_int, [_11, ]) 7 | } 8 | Apply(main.12, []) 9 | -------------------------------------------------------------------------------- /test/test_src/id.mbt: -------------------------------------------------------------------------------- 1 | //:extension 2 | 3 | fn f[T](x: T) -> T { 4 | x 5 | }; 6 | 7 | fn main { 8 | print_int(f(1000)); 9 | print_int(int_of_float(f(1000.0))) 10 | }; -------------------------------------------------------------------------------- /test/test_src/id.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: forall [("T", None)] . (x: T) -> T { 2 | Var(x) 3 | } 4 | let rec main: () -> Var(None) { 5 | let _: Var(None) = Apply(Var("print_int"), [App(Var("f"), targs=None, [Int(1000)]), ]) 6 | Apply(Var("print_int"), [App(Var("int_of_float"), targs=None, [App(Var("f"), targs=None, [Double(1000)])]), ]) 7 | } 8 | Unit 9 | -------------------------------------------------------------------------------- /test/test_src/id.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: forall [("T", None)] . (x: T) -> T { 2 | Var(x) 3 | } 4 | let rec main: () -> Unit { 5 | let _: Unit = Apply[](Var("print_int"), [App(Var("f"), targs=Some([("T", Int)]), [Int(1000)]), ]) 6 | Apply[](Var("print_int"), [App(Var("int_of_float"), targs=Some([]), [App(Var("f"), targs=Some([("T", Double)]), [Double(1000)])]), ]) 7 | } 8 | Unit 9 | -------------------------------------------------------------------------------- /test/test_src/id.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec f: forall [("T", None)] . (x: T) -> T { 2 | Var(x) 3 | } 4 | let rec main: () -> Unit { 5 | let _: Unit = Apply[](Var("print_int"), [App(Var("f"), targs=Some([("T", Int)]), [Int(1000)]), ]) 6 | Apply[](Var("print_int"), [App(Var("int_of_float"), targs=Some([]), [App(Var("f"), targs=Some([("T", Double)]), [Double(1000)])]), ]) 7 | } 8 | Unit 9 | -------------------------------------------------------------------------------- /test/test_src/inprod-loop.ans: -------------------------------------------------------------------------------- 1 | 16826400 2 | -------------------------------------------------------------------------------- /test/test_src/inprod-loop.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {inprod.1: @hashset.of([]), main.17: @hashset.of([inprod.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/inprod-loop.mbt: -------------------------------------------------------------------------------- 1 | fn inprod(v1: Array[Double], v2: Array[Double], acc: Double, i: Int) -> Double { 2 | if 0 <= i { 3 | inprod(v1, v2, acc + v1[i] * v2[i], i - 1) 4 | } else { 5 | acc 6 | } 7 | }; 8 | 9 | fn main { 10 | let v1 = Array::make(3, 1.23); 11 | let v2 = Array::make(3, 4.56); 12 | print_int(truncate(1000000.0 * inprod(v1, v2, 0.0, 2))) 13 | }; -------------------------------------------------------------------------------- /test/test_src/inprod-rec.ans: -------------------------------------------------------------------------------- 1 | 16826400 2 | -------------------------------------------------------------------------------- /test/test_src/inprod-rec.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {inprod.1: @hashset.of([]), main.15: @hashset.of([inprod.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/inprod-rec.mbt: -------------------------------------------------------------------------------- 1 | fn inprod(v1: Array[Double], v2: Array[Double], i: Int) -> Double { 2 | if 0 <= i { 3 | v1[i] * v2[i] + inprod(v1, v2, i - 1) 4 | } else { 5 | 0.0 6 | } 7 | }; 8 | 9 | fn main { 10 | let v1 = Array::make(3, 1.23); 11 | let v2 = Array::make(3, 4.56); 12 | print_int(truncate(1000000.0 * inprod(v1, v2, 2))) 13 | }; -------------------------------------------------------------------------------- /test/test_src/inprod.ans: -------------------------------------------------------------------------------- 1 | 32000000 2 | -------------------------------------------------------------------------------- /test/test_src/inprod.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.43: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/inprod.mbt: -------------------------------------------------------------------------------- 1 | fn getx(v: (Double,Double,Double)) -> Double { 2 | let (x, _, _) = v; 3 | x 4 | }; 5 | 6 | fn gety(v: (Double,Double,Double)) -> Double { 7 | let (_, y, _) = v; 8 | y 9 | }; 10 | 11 | fn getz(v: (Double,Double,Double)) -> Double { 12 | let (_, _, z) = v; 13 | z 14 | }; 15 | 16 | fn inprod(v1: (Double,Double,Double), v2: (Double,Double,Double)) -> Double { 17 | getx(v1) * getx(v2) + gety(v1) * gety(v2) + getz(v1) * getz(v2) 18 | }; 19 | 20 | fn main { 21 | print_int(truncate(1000000.0 * inprod((1.0, 2.0, 3.0), (4.0, 5.0, 6.0)))) 22 | }; -------------------------------------------------------------------------------- /test/test_src/int_min.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.2: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf.txt: -------------------------------------------------------------------------------- 1 | let int_min.1: Int = Int(-2147483648) 2 | let rec main.2: Unit = () { 3 | let _4: Unit = ExtApply(minimbt_print_int, [int_min.1, ]) 4 | Unit 5 | } 6 | Apply(main.2, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.2: Unit = () { 2 | let _5: Int = Int(-2147483648) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | Unit 5 | } 6 | Apply(main.2, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.2: Unit = () { 2 | let _5: Int = Int(-2147483648) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | Unit 5 | } 6 | Apply(main.2, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.2: Unit = () { 2 | let _5: Int = Int(-2147483648) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | Unit 5 | } 6 | Apply(main.2, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.6: Unit = () { 2 | let _5: Int = Int(-2147483648) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | Unit 5 | } 6 | Apply(main.6, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.6: Unit = () { 2 | let _5: Int = Int(-2147483648) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | Unit 5 | } 6 | Apply(main.6, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.6: Unit = () { 2 | let _5: Int = Int(-2147483648) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | Unit 5 | } 6 | Apply(main.6, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.6: Unit = () { 2 | let _5: Int = Int(-2147483648) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | Unit 5 | } 6 | Apply(main.6, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.6: Unit = () { 2 | let _5: Int = Int(-2147483648) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_5, ]) 4 | Unit 5 | } 6 | Apply(main.6, []) 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.mbt: -------------------------------------------------------------------------------- 1 | let int_min: Int = -2147483648; 2 | 3 | fn main { 4 | print_int(int_min); 5 | () 6 | } -------------------------------------------------------------------------------- /test/test_src/int_min.resolved.txt: -------------------------------------------------------------------------------- 1 | let int_min: Int = Neg(Int(2147483648)) 2 | let rec main: () -> Var(None) { 3 | let _: Var(None) = Apply(Var("print_int"), [Var("int_min"), ]) 4 | Unit 5 | } 6 | Unit 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.typer.txt: -------------------------------------------------------------------------------- 1 | let int_min: Int = Neg(Int(2147483648)) 2 | let rec main: () -> Unit { 3 | let _: Unit = Apply[](Var("print_int"), [Var("int_min"), ]) 4 | Unit 5 | } 6 | Unit 7 | -------------------------------------------------------------------------------- /test/test_src/int_min.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let int_min: Int = Neg(Int(2147483648)) 2 | let rec main: () -> Unit { 3 | let _: Unit = Apply[](Var("print_int"), [Var("int_min"), ]) 4 | Unit 5 | } 6 | Unit 7 | -------------------------------------------------------------------------------- /test/test_src/join-reg.ans: -------------------------------------------------------------------------------- 1 | 912 2 | -------------------------------------------------------------------------------- /test/test_src/join-reg.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.10: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/join-reg.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _20: Int = if (_16 == _17) then { 10 | Int(-333) 11 | } else { 12 | let _18: Int = Int(333) 13 | let _19: Int = Int(456) 14 | Int(912) 15 | } 16 | ExtApply(minimbt_print_int, [_20, ]) 17 | } 18 | Apply(main.10, []) 19 | -------------------------------------------------------------------------------- /test/test_src/join-reg.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _20: Int = if (_16 == _17) then { 10 | Int(-333) 11 | } else { 12 | let _18: Int = Int(333) 13 | let _19: Int = Int(456) 14 | Int(912) 15 | } 16 | ExtApply(minimbt_print_int, [_20, ]) 17 | } 18 | Apply(main.10, []) 19 | -------------------------------------------------------------------------------- /test/test_src/join-reg.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _20: Int = if (_16 == _17) then { 10 | Int(-333) 11 | } else { 12 | let _18: Int = Int(333) 13 | let _19: Int = Int(456) 14 | Int(912) 15 | } 16 | ExtApply(minimbt_print_int, [_20, ]) 17 | } 18 | Apply(main.10, []) 19 | -------------------------------------------------------------------------------- /test/test_src/join-reg.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.21: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _20: Int = if (_16 == _17) then { 10 | Int(-333) 11 | } else { 12 | let _18: Int = Int(333) 13 | let _19: Int = Int(456) 14 | Int(912) 15 | } 16 | ExtApply(minimbt_print_int, [_20, ]) 17 | } 18 | Apply(main.21, []) 19 | -------------------------------------------------------------------------------- /test/test_src/join-reg.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.21: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _20: Int = if (_16 == _17) then { 10 | Int(-333) 11 | } else { 12 | let _18: Int = Int(333) 13 | let _19: Int = Int(456) 14 | Int(912) 15 | } 16 | ExtApply(minimbt_print_int, [_20, ]) 17 | } 18 | Apply(main.21, []) 19 | -------------------------------------------------------------------------------- /test/test_src/join-reg.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.21: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _20: Int = if (_16 == _17) then { 10 | Int(-333) 11 | } else { 12 | let _18: Int = Int(333) 13 | let _19: Int = Int(456) 14 | Int(912) 15 | } 16 | ExtApply(minimbt_print_int, [_20, ]) 17 | } 18 | Apply(main.21, []) 19 | -------------------------------------------------------------------------------- /test/test_src/join-reg.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.21: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _20: Int = if (_16 == _17) then { 10 | Int(-333) 11 | } else { 12 | let _18: Int = Int(333) 13 | let _19: Int = Int(456) 14 | Int(912) 15 | } 16 | ExtApply(minimbt_print_int, [_20, ]) 17 | } 18 | Apply(main.21, []) 19 | -------------------------------------------------------------------------------- /test/test_src/join-reg.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.21: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _20: Int = if (_16 == _17) then { 10 | Int(-333) 11 | } else { 12 | let _18: Int = Int(333) 13 | let _19: Int = Int(456) 14 | Int(912) 15 | } 16 | ExtApply(minimbt_print_int, [_20, ]) 17 | } 18 | Apply(main.21, []) 19 | -------------------------------------------------------------------------------- /test/test_src/join-reg.mbt: -------------------------------------------------------------------------------- 1 | fn f(x: Unit) -> Int { 2 | 123 3 | }; 4 | 5 | fn g(x: Unit) -> Int { 6 | 456 7 | }; 8 | 9 | fn h(x: Unit) -> Int { 10 | 789 11 | }; 12 | 13 | fn main { 14 | let x = f(()); 15 | let y = g(()); 16 | print_int(if h(()) == 0 { x - y } else { y - x } + x + y) 17 | }; -------------------------------------------------------------------------------- /test/test_src/join-reg.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: (x: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (x: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (x: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Var(None) { 11 | let x: Var(None) = Apply(Var("f"), [Unit, ]) 12 | let y: Var(None) = Apply(Var("g"), [Unit, ]) 13 | Apply(Var("print_int"), [If(Eq(App(Var("h"), targs=None, [Unit]), Int(0)), Prim(Var("x"), Var("y"), Sub, kind=None), Prim(Prim(Prim(Var("y"), Var("x"), Sub, kind=None), Var("x"), Add, kind=None), Var("y"), Add, kind=None)), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/join-reg.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: (x: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (x: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (x: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Unit { 11 | let x: Int = Apply[](Var("f"), [Unit, ]) 12 | let y: Int = Apply[](Var("g"), [Unit, ]) 13 | Apply[](Var("print_int"), [If(Eq(App(Var("h"), targs=Some([]), [Unit]), Int(0)), Prim(Var("x"), Var("y"), Sub, kind=Some(Int)), Prim(Prim(Prim(Var("y"), Var("x"), Sub, kind=Some(Int)), Var("x"), Add, kind=Some(Int)), Var("y"), Add, kind=Some(Int))), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.ans: -------------------------------------------------------------------------------- 1 | 789 2 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.10: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _19: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | let _15: Int = Int(456) 8 | Int(579) 9 | } else { 10 | let _16: Unit = Unit 11 | let _17: Int = Int(789) 12 | let _18: Int = Int(666) 13 | Int(789) 14 | } 15 | ExtApply(minimbt_print_int, [_19, ]) 16 | } 17 | Apply(main.10, []) 18 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _19: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | let _15: Int = Int(456) 8 | Int(579) 9 | } else { 10 | let _16: Unit = Unit 11 | let _17: Int = Int(789) 12 | let _18: Int = Int(666) 13 | Int(789) 14 | } 15 | ExtApply(minimbt_print_int, [_19, ]) 16 | } 17 | Apply(main.10, []) 18 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _19: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | let _15: Int = Int(456) 8 | Int(579) 9 | } else { 10 | let _16: Unit = Unit 11 | let _17: Int = Int(789) 12 | let _18: Int = Int(666) 13 | Int(789) 14 | } 15 | ExtApply(minimbt_print_int, [_19, ]) 16 | } 17 | Apply(main.10, []) 18 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.20: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _19: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | let _15: Int = Int(456) 8 | Int(579) 9 | } else { 10 | let _16: Unit = Unit 11 | let _17: Int = Int(789) 12 | let _18: Int = Int(666) 13 | Int(789) 14 | } 15 | ExtApply(minimbt_print_int, [_19, ]) 16 | } 17 | Apply(main.20, []) 18 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.20: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _19: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | let _15: Int = Int(456) 8 | Int(579) 9 | } else { 10 | let _16: Unit = Unit 11 | let _17: Int = Int(789) 12 | let _18: Int = Int(666) 13 | Int(789) 14 | } 15 | ExtApply(minimbt_print_int, [_19, ]) 16 | } 17 | Apply(main.20, []) 18 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.20: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _19: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | let _15: Int = Int(456) 8 | Int(579) 9 | } else { 10 | let _16: Unit = Unit 11 | let _17: Int = Int(789) 12 | let _18: Int = Int(666) 13 | Int(789) 14 | } 15 | ExtApply(minimbt_print_int, [_19, ]) 16 | } 17 | Apply(main.20, []) 18 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.20: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _19: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | let _15: Int = Int(456) 8 | Int(579) 9 | } else { 10 | let _16: Unit = Unit 11 | let _17: Int = Int(789) 12 | let _18: Int = Int(666) 13 | Int(789) 14 | } 15 | ExtApply(minimbt_print_int, [_19, ]) 16 | } 17 | Apply(main.20, []) 18 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.20: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _19: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | let _15: Int = Int(456) 8 | Int(579) 9 | } else { 10 | let _16: Unit = Unit 11 | let _17: Int = Int(789) 12 | let _18: Int = Int(666) 13 | Int(789) 14 | } 15 | ExtApply(minimbt_print_int, [_19, ]) 16 | } 17 | Apply(main.20, []) 18 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.mbt: -------------------------------------------------------------------------------- 1 | fn f(u: Unit) -> Int { 2 | 123 3 | }; 4 | 5 | fn g(u: Unit) -> Int { 6 | 456 7 | }; 8 | 9 | fn h(u: Unit) -> Int { 10 | 789 11 | }; 12 | 13 | fn main { 14 | let x = f(()); 15 | print_int(if x <= 0 { g(()) + x } else { h(()) - x } + x) 16 | }; -------------------------------------------------------------------------------- /test/test_src/join-reg2.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (u: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Var(None) { 11 | let x: Var(None) = Apply(Var("f"), [Unit, ]) 12 | Apply(Var("print_int"), [If(LE(Var("x"), Int(0)), Prim(App(Var("g"), targs=None, [Unit]), Var("x"), Add, kind=None), Prim(Prim(App(Var("h"), targs=None, [Unit]), Var("x"), Sub, kind=None), Var("x"), Add, kind=None)), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (u: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Unit { 11 | let x: Int = Apply[](Var("f"), [Unit, ]) 12 | Apply[](Var("print_int"), [If(LE(Var("x"), Int(0)), Prim(App(Var("g"), targs=Some([]), [Unit]), Var("x"), Add, kind=Some(Int)), Prim(Prim(App(Var("h"), targs=Some([]), [Unit]), Var("x"), Sub, kind=Some(Int)), Var("x"), Add, kind=Some(Int))), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/join-reg2.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (u: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Unit { 11 | let x: Int = Apply[](Var("f"), [Unit, ]) 12 | Apply[](Var("print_int"), [If(LE(Var("x"), Int(0)), Prim(App(Var("g"), targs=Some([]), [Unit]), Var("x"), Add, kind=Some(Int)), Prim(Prim(App(Var("h"), targs=Some([]), [Unit]), Var("x"), Sub, kind=Some(Int)), Var("x"), Add, kind=Some(Int))), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack.ans: -------------------------------------------------------------------------------- 1 | 1037 2 | -------------------------------------------------------------------------------- /test/test_src/join-stack.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.10: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/join-stack.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _22: Int = if (_16 == _17) then { 10 | let _18: Int = Int(1) 11 | Int(124) 12 | } else { 13 | let _19: Int = Int(2) 14 | let _20: Int = Int(458) 15 | let _21: Int = Int(581) 16 | Int(1037) 17 | } 18 | ExtApply(minimbt_print_int, [_22, ]) 19 | } 20 | Apply(main.10, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _22: Int = if (_16 == _17) then { 10 | let _18: Int = Int(1) 11 | Int(124) 12 | } else { 13 | let _19: Int = Int(2) 14 | let _20: Int = Int(458) 15 | let _21: Int = Int(581) 16 | Int(1037) 17 | } 18 | ExtApply(minimbt_print_int, [_22, ]) 19 | } 20 | Apply(main.10, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _22: Int = if (_16 == _17) then { 10 | let _18: Int = Int(1) 11 | Int(124) 12 | } else { 13 | let _19: Int = Int(2) 14 | let _20: Int = Int(458) 15 | let _21: Int = Int(581) 16 | Int(1037) 17 | } 18 | ExtApply(minimbt_print_int, [_22, ]) 19 | } 20 | Apply(main.10, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.23: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _22: Int = if (_16 == _17) then { 10 | let _18: Int = Int(1) 11 | Int(124) 12 | } else { 13 | let _19: Int = Int(2) 14 | let _20: Int = Int(458) 15 | let _21: Int = Int(581) 16 | Int(1037) 17 | } 18 | ExtApply(minimbt_print_int, [_22, ]) 19 | } 20 | Apply(main.23, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.23: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _22: Int = if (_16 == _17) then { 10 | let _18: Int = Int(1) 11 | Int(124) 12 | } else { 13 | let _19: Int = Int(2) 14 | let _20: Int = Int(458) 15 | let _21: Int = Int(581) 16 | Int(1037) 17 | } 18 | ExtApply(minimbt_print_int, [_22, ]) 19 | } 20 | Apply(main.23, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.23: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _22: Int = if (_16 == _17) then { 10 | let _18: Int = Int(1) 11 | Int(124) 12 | } else { 13 | let _19: Int = Int(2) 14 | let _20: Int = Int(458) 15 | let _21: Int = Int(581) 16 | Int(1037) 17 | } 18 | ExtApply(minimbt_print_int, [_22, ]) 19 | } 20 | Apply(main.23, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.23: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _22: Int = if (_16 == _17) then { 10 | let _18: Int = Int(1) 11 | Int(124) 12 | } else { 13 | let _19: Int = Int(2) 14 | let _20: Int = Int(458) 15 | let _21: Int = Int(581) 16 | Int(1037) 17 | } 18 | ExtApply(minimbt_print_int, [_22, ]) 19 | } 20 | Apply(main.23, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.23: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Unit = Unit 5 | let y.14: Int = Int(456) 6 | let _15: Unit = Unit 7 | let _16: Int = Int(789) 8 | let _17: Int = Int(0) 9 | let _22: Int = if (_16 == _17) then { 10 | let _18: Int = Int(1) 11 | Int(124) 12 | } else { 13 | let _19: Int = Int(2) 14 | let _20: Int = Int(458) 15 | let _21: Int = Int(581) 16 | Int(1037) 17 | } 18 | ExtApply(minimbt_print_int, [_22, ]) 19 | } 20 | Apply(main.23, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack.mbt: -------------------------------------------------------------------------------- 1 | fn f(u: Unit) -> Int { 2 | 123 3 | }; 4 | 5 | fn g(u: Unit) -> Int { 6 | 456 7 | }; 8 | 9 | fn h(u: Unit) -> Int { 10 | 789 11 | }; 12 | 13 | fn main { 14 | let x = f(()); 15 | let y = g(()); 16 | print_int(if h(()) == 0 { x + 1 } else { y + 2 } + x + y) 17 | }; -------------------------------------------------------------------------------- /test/test_src/join-stack.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (u: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Var(None) { 11 | let x: Var(None) = Apply(Var("f"), [Unit, ]) 12 | let y: Var(None) = Apply(Var("g"), [Unit, ]) 13 | Apply(Var("print_int"), [If(Eq(App(Var("h"), targs=None, [Unit]), Int(0)), Prim(Var("x"), Int(1), Add, kind=None), Prim(Prim(Prim(Var("y"), Int(2), Add, kind=None), Var("x"), Add, kind=None), Var("y"), Add, kind=None)), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (u: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Unit { 11 | let x: Int = Apply[](Var("f"), [Unit, ]) 12 | let y: Int = Apply[](Var("g"), [Unit, ]) 13 | Apply[](Var("print_int"), [If(Eq(App(Var("h"), targs=Some([]), [Unit]), Int(0)), Prim(Var("x"), Int(1), Add, kind=Some(Int)), Prim(Prim(Prim(Var("y"), Int(2), Add, kind=Some(Int)), Var("x"), Add, kind=Some(Int)), Var("y"), Add, kind=Some(Int))), ]) 14 | } 15 | Unit 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.ans: -------------------------------------------------------------------------------- 1 | 246 2 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.7: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf.txt: -------------------------------------------------------------------------------- 1 | let rec f.1: Int = (u.3: Unit) { 2 | Int(123) 3 | } 4 | let rec g.4: Int = (u.6: Unit) { 5 | Int(456) 6 | } 7 | let rec main.7: Unit = () { 8 | let _8: Unit = Unit 9 | let x.9: Int = Apply(f.1, [_8, ]) 10 | let _10: Int = Int(0) 11 | let _13: Int = if (x.9 <= _10) then { 12 | let _11: Unit = Unit 13 | let _12: Int = Apply(g.4, [_11, ]) 14 | Add(_12, x.9) 15 | } else { 16 | Add(x.9, x.9) 17 | } 18 | ExtApply(minimbt_print_int, [_13, ]) 19 | } 20 | Apply(main.7, []) 21 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Unit = Unit 3 | let x.9: Int = Int(123) 4 | let _10: Int = Int(0) 5 | let _13: Int = if (x.9 <= _10) then { 6 | let _11: Unit = Unit 7 | let _12: Int = Int(456) 8 | Int(579) 9 | } else { 10 | Int(246) 11 | } 12 | ExtApply(minimbt_print_int, [_13, ]) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Unit = Unit 3 | let x.9: Int = Int(123) 4 | let _10: Int = Int(0) 5 | let _13: Int = if (x.9 <= _10) then { 6 | let _11: Unit = Unit 7 | let _12: Int = Int(456) 8 | Int(579) 9 | } else { 10 | Int(246) 11 | } 12 | ExtApply(minimbt_print_int, [_13, ]) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.7: Unit = () { 2 | let _8: Unit = Unit 3 | let x.9: Int = Int(123) 4 | let _10: Int = Int(0) 5 | let _13: Int = if (x.9 <= _10) then { 6 | let _11: Unit = Unit 7 | let _12: Int = Int(456) 8 | Int(579) 9 | } else { 10 | Int(246) 11 | } 12 | ExtApply(minimbt_print_int, [_13, ]) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _8: Unit = Unit 3 | let x.9: Int = Int(123) 4 | let _10: Int = Int(0) 5 | let _13: Int = if (x.9 <= _10) then { 6 | let _11: Unit = Unit 7 | let _12: Int = Int(456) 8 | Int(579) 9 | } else { 10 | Int(246) 11 | } 12 | ExtApply(minimbt_print_int, [_13, ]) 13 | } 14 | Apply(main.14, []) 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _8: Unit = Unit 3 | let x.9: Int = Int(123) 4 | let _10: Int = Int(0) 5 | let _13: Int = if (x.9 <= _10) then { 6 | let _11: Unit = Unit 7 | let _12: Int = Int(456) 8 | Int(579) 9 | } else { 10 | Int(246) 11 | } 12 | ExtApply(minimbt_print_int, [_13, ]) 13 | } 14 | Apply(main.14, []) 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _8: Unit = Unit 3 | let x.9: Int = Int(123) 4 | let _10: Int = Int(0) 5 | let _13: Int = if (x.9 <= _10) then { 6 | let _11: Unit = Unit 7 | let _12: Int = Int(456) 8 | Int(579) 9 | } else { 10 | Int(246) 11 | } 12 | ExtApply(minimbt_print_int, [_13, ]) 13 | } 14 | Apply(main.14, []) 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _8: Unit = Unit 3 | let x.9: Int = Int(123) 4 | let _10: Int = Int(0) 5 | let _13: Int = if (x.9 <= _10) then { 6 | let _11: Unit = Unit 7 | let _12: Int = Int(456) 8 | Int(579) 9 | } else { 10 | Int(246) 11 | } 12 | ExtApply(minimbt_print_int, [_13, ]) 13 | } 14 | Apply(main.14, []) 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.14: Unit = () { 2 | let _8: Unit = Unit 3 | let x.9: Int = Int(123) 4 | let _10: Int = Int(0) 5 | let _13: Int = if (x.9 <= _10) then { 6 | let _11: Unit = Unit 7 | let _12: Int = Int(456) 8 | Int(579) 9 | } else { 10 | Int(246) 11 | } 12 | ExtApply(minimbt_print_int, [_13, ]) 13 | } 14 | Apply(main.14, []) 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.mbt: -------------------------------------------------------------------------------- 1 | fn f(u: Unit) -> Int { 2 | 123 3 | }; 4 | 5 | fn g(u: Unit) -> Int { 6 | 456 7 | }; 8 | 9 | fn main { 10 | let x = f(()); 11 | print_int(if x <= 0 { g(()) + x } else { x } + x) 12 | }; -------------------------------------------------------------------------------- /test/test_src/join-stack2.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec main: () -> Var(None) { 8 | let x: Var(None) = Apply(Var("f"), [Unit, ]) 9 | Apply(Var("print_int"), [If(LE(Var("x"), Int(0)), Prim(App(Var("g"), targs=None, [Unit]), Var("x"), Add, kind=None), Prim(Var("x"), Var("x"), Add, kind=None)), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec main: () -> Unit { 8 | let x: Int = Apply[](Var("f"), [Unit, ]) 9 | Apply[](Var("print_int"), [If(LE(Var("x"), Int(0)), Prim(App(Var("g"), targs=Some([]), [Unit]), Var("x"), Add, kind=Some(Int)), Prim(Var("x"), Var("x"), Add, kind=Some(Int))), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/join-stack2.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec main: () -> Unit { 8 | let x: Int = Apply[](Var("f"), [Unit, ]) 9 | Apply[](Var("print_int"), [If(LE(Var("x"), Int(0)), Prim(App(Var("g"), targs=Some([]), [Unit]), Var("x"), Add, kind=Some(Int)), Prim(Var("x"), Var("x"), Add, kind=Some(Int))), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.ans: -------------------------------------------------------------------------------- 1 | 912 2 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.10: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _16: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | Int(456) 8 | } else { 9 | let _15: Unit = Unit 10 | Int(789) 11 | } 12 | let _17: Int = Add(_16, x.12) 13 | ExtApply(minimbt_print_int, [_17, ]) 14 | } 15 | Apply(main.10, []) 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _16: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | Int(456) 8 | } else { 9 | let _15: Unit = Unit 10 | Int(789) 11 | } 12 | let _17: Int = Add(_16, x.12) 13 | ExtApply(minimbt_print_int, [_17, ]) 14 | } 15 | Apply(main.10, []) 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.10: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _16: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | Int(456) 8 | } else { 9 | let _15: Unit = Unit 10 | Int(789) 11 | } 12 | let _17: Int = Add(_16, x.12) 13 | ExtApply(minimbt_print_int, [_17, ]) 14 | } 15 | Apply(main.10, []) 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _16: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | Int(456) 8 | } else { 9 | let _15: Unit = Unit 10 | Int(789) 11 | } 12 | let _17: Int = Add(_16, x.12) 13 | ExtApply(minimbt_print_int, [_17, ]) 14 | } 15 | Apply(main.18, []) 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _16: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | Int(456) 8 | } else { 9 | let _15: Unit = Unit 10 | Int(789) 11 | } 12 | let _17: Int = Add(_16, x.12) 13 | ExtApply(minimbt_print_int, [_17, ]) 14 | } 15 | Apply(main.18, []) 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _16: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | Int(456) 8 | } else { 9 | let _15: Unit = Unit 10 | Int(789) 11 | } 12 | let _17: Int = Add(_16, x.12) 13 | ExtApply(minimbt_print_int, [_17, ]) 14 | } 15 | Apply(main.18, []) 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _16: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | Int(456) 8 | } else { 9 | let _15: Unit = Unit 10 | Int(789) 11 | } 12 | let _17: Int = Add(_16, x.12) 13 | ExtApply(minimbt_print_int, [_17, ]) 14 | } 15 | Apply(main.18, []) 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.18: Unit = () { 2 | let _11: Unit = Unit 3 | let x.12: Int = Int(123) 4 | let _13: Int = Int(0) 5 | let _16: Int = if (x.12 <= _13) then { 6 | let _14: Unit = Unit 7 | Int(456) 8 | } else { 9 | let _15: Unit = Unit 10 | Int(789) 11 | } 12 | let _17: Int = Add(_16, x.12) 13 | ExtApply(minimbt_print_int, [_17, ]) 14 | } 15 | Apply(main.18, []) 16 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.mbt: -------------------------------------------------------------------------------- 1 | fn f(u: Unit) -> Int { 2 | 123 3 | }; 4 | 5 | fn g(u: Unit) -> Int { 6 | 456 7 | }; 8 | 9 | fn h(u: Unit) -> Int { 10 | 789 11 | }; 12 | 13 | fn main { 14 | let x = f(()); 15 | print_int((if x <= 0 { g(()) } else { h(()) }) + x) 16 | }; -------------------------------------------------------------------------------- /test/test_src/join-stack3.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (u: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Var(None) { 11 | let x: Var(None) = Apply(Var("f"), [Unit, ]) 12 | Apply(Var("print_int"), [Prim(If(LE(Var("x"), Int(0)), App(Var("g"), targs=None, [Unit]), App(Var("h"), targs=None, [Unit])), Var("x"), Add, kind=None), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.typer.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (u: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Unit { 11 | let x: Int = Apply[](Var("f"), [Unit, ]) 12 | Apply[](Var("print_int"), [Prim(If(LE(Var("x"), Int(0)), App(Var("g"), targs=Some([]), [Unit]), App(Var("h"), targs=Some([]), [Unit])), Var("x"), Add, kind=Some(Int)), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/join-stack3.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec f: (u: Unit) -> Int { 2 | Int(123) 3 | } 4 | let rec g: (u: Unit) -> Int { 5 | Int(456) 6 | } 7 | let rec h: (u: Unit) -> Int { 8 | Int(789) 9 | } 10 | let rec main: () -> Unit { 11 | let x: Int = Apply[](Var("f"), [Unit, ]) 12 | Apply[](Var("print_int"), [Prim(If(LE(Var("x"), Int(0)), App(Var("g"), targs=Some([]), [Unit]), App(Var("h"), targs=Some([]), [Unit])), Var("x"), Add, kind=Some(Int)), ]) 13 | } 14 | Unit 15 | -------------------------------------------------------------------------------- /test/test_src/landins_knot.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {dummy.1: @hashset.of([]), h.60: @hashset.of([arr.47]), main.37: @hashset.of([a.33, arr.47, h.60])} 2 | -------------------------------------------------------------------------------- /test/test_src/mandelbrot.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {iloop.97: @hashset.of([]), xloop.81: @hashset.of([_76]), yloop.79: @hashset.of([_76]), main.75: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/manyargs.ans: -------------------------------------------------------------------------------- 1 | 57 2 | -------------------------------------------------------------------------------- /test/test_src/matmul-flat.ans: -------------------------------------------------------------------------------- 1 | 58 2 | 64 3 | 139 4 | 154 5 | 6 | -------------------------------------------------------------------------------- /test/test_src/matmul-flat.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {loop3.1: @hashset.of([]), loop2.28: @hashset.of([loop3.1]), loop1.48: @hashset.of([loop2.28, loop3.1]), init_arr.89: @hashset.of([]), make_arr.103: @hashset.of([init_arr.89]), main.85: @hashset.of([loop2.28, loop3.1, loop1.48])} 2 | -------------------------------------------------------------------------------- /test/test_src/matmul.ans: -------------------------------------------------------------------------------- 1 | 58 2 | 64 3 | 139 4 | 154 5 | 6 | -------------------------------------------------------------------------------- /test/test_src/matmul.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {init_arr.63: @hashset.of([n.61, mat.62]), gen_arr.57: @hashset.of([dummy.56]), loop3.203: @hashset.of([j.201, c.85, a.79, i.198, b.82]), loop2.200: @hashset.of([c.85, a.79, b.82, i.198]), loop1.197: @hashset.of([c.85, a.79, b.82]), main.53: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/min.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.1: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/min.knf.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.1, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.1, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.1, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.1, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.3: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.3, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.3: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.3, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.3: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.3, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.3: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.3, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.3: Unit = () { 2 | let _2: Int = Int(0) 3 | ExtApply(minimbt_print_int, [_2, ]) 4 | } 5 | Apply(main.3, []) 6 | -------------------------------------------------------------------------------- /test/test_src/min.mbt: -------------------------------------------------------------------------------- 1 | fn main { 2 | print_int(0) 3 | } -------------------------------------------------------------------------------- /test/test_src/min.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Var(None) { 2 | Apply(Var("print_int"), [Int(0), ]) 3 | } 4 | Unit 5 | -------------------------------------------------------------------------------- /test/test_src/min.typer.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | Apply[](Var("print_int"), [Int(0), ]) 3 | } 4 | Unit 5 | -------------------------------------------------------------------------------- /test/test_src/min.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | Apply[](Var("print_int"), [Int(0), ]) 3 | } 4 | Unit 5 | -------------------------------------------------------------------------------- /test/test_src/multiple-init.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.32: @hashset.of([len.3, len2.13])} 2 | -------------------------------------------------------------------------------- /test/test_src/multiple-init.mbt: -------------------------------------------------------------------------------- 1 | let len: Array[Int] = Array::make(1, 0); 2 | fn init { 3 | len[0] = 1; 4 | () 5 | }; 6 | let len2: Array[Int] = Array::make(1, 0); 7 | fn init { 8 | len2[0] = 2; 9 | () 10 | }; 11 | 12 | fn init { 13 | len[0] = 3; 14 | len2[0] = 4; 15 | () 16 | }; 17 | 18 | fn main { 19 | let _ = print_int(len[0]); 20 | let _ = print_endline(); 21 | let _ = print_int(len2[0]); 22 | () 23 | } -------------------------------------------------------------------------------- /test/test_src/non-tail-if.ans: -------------------------------------------------------------------------------- 1 | -10 2 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.1: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if.mbt: -------------------------------------------------------------------------------- 1 | fn main { 2 | let x = truncate(1.23); 3 | let y = truncate(4.56); 4 | let z = truncate(-7.89); 5 | print_int( 6 | (if 0 <= z { x } else { y }) + 7 | (if x <= 0 { y } else { z }) + 8 | (if 0 <= y { z } else { x }) 9 | ) 10 | }; -------------------------------------------------------------------------------- /test/test_src/non-tail-if.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Var(None) { 2 | let x: Var(None) = Apply(Var("truncate"), [Double(1.23), ]) 3 | let y: Var(None) = Apply(Var("truncate"), [Double(4.56), ]) 4 | let z: Var(None) = Apply(Var("truncate"), [Neg(Double(7.89), kind=None), ]) 5 | Apply(Var("print_int"), [Prim(Prim(If(LE(Int(0), Var("z")), Var("x"), Var("y")), If(LE(Var("x"), Int(0)), Var("y"), Var("z")), Add, kind=None), If(LE(Int(0), Var("y")), Var("z"), Var("x")), Add, kind=None), ]) 6 | } 7 | Unit 8 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if.typer.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | let x: Int = Apply[](Var("truncate"), [Double(1.23), ]) 3 | let y: Int = Apply[](Var("truncate"), [Double(4.56), ]) 4 | let z: Int = Apply[](Var("truncate"), [Neg(Double(7.89), kind=Some(Double)), ]) 5 | Apply[](Var("print_int"), [Prim(Prim(If(LE(Int(0), Var("z")), Var("x"), Var("y")), If(LE(Var("x"), Int(0)), Var("y"), Var("z")), Add, kind=Some(Int)), If(LE(Int(0), Var("y")), Var("z"), Var("x")), Add, kind=Some(Int)), ]) 6 | } 7 | Unit 8 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | let x: Int = Apply[](Var("truncate"), [Double(1.23), ]) 3 | let y: Int = Apply[](Var("truncate"), [Double(4.56), ]) 4 | let z: Int = Apply[](Var("truncate"), [Neg(Double(7.89), kind=Some(Double)), ]) 5 | Apply[](Var("print_int"), [Prim(Prim(If(LE(Int(0), Var("z")), Var("x"), Var("y")), If(LE(Var("x"), Int(0)), Var("y"), Var("z")), Add, kind=Some(Int)), If(LE(Int(0), Var("y")), Var("z"), Var("x")), Add, kind=Some(Int)), ]) 6 | } 7 | Unit 8 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if2.ans: -------------------------------------------------------------------------------- 1 | 80238 2 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if2.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.1: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if2.mbt: -------------------------------------------------------------------------------- 1 | fn main { 2 | fn f() -> Int { 3 | 12345 4 | }; 5 | let y = Array::make(10, 3); 6 | let x = 67890; 7 | print_int(if y[0] == 3 { f() + y[1] + x } else { 7 }) 8 | }; -------------------------------------------------------------------------------- /test/test_src/non-tail-if2.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Var(None) { 2 | let rec f: () -> Int { 3 | Int(12345) 4 | } 5 | let y: Var(None) = Array::make(Int(10), Int(3)) 6 | let x: Var(None) = Int(67890) 7 | Apply(Var("print_int"), [If(Eq(Get(Var("y"), Int(0)), Int(3)), Prim(Prim(App(Var("f"), targs=None, []), Get(Var("y"), Int(1)), Add, kind=None), Var("x"), Add, kind=None), Int(7)), ]) 8 | } 9 | Unit 10 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if2.typer.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | let rec f: () -> Int { 3 | Int(12345) 4 | } 5 | let y: Array[Int] = Array::make(Int(10), Int(3)) 6 | let x: Int = Int(67890) 7 | Apply[](Var("print_int"), [If(Eq(Get(Var("y"), Int(0)), Int(3)), Prim(Prim(App(Var("f"), targs=Some([]), []), Get(Var("y"), Int(1)), Add, kind=Some(Int)), Var("x"), Add, kind=Some(Int)), Int(7)), ]) 8 | } 9 | Unit 10 | -------------------------------------------------------------------------------- /test/test_src/non-tail-if2.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | let rec f: () -> Int { 3 | Int(12345) 4 | } 5 | let y: Array[Int] = Array::make(Int(10), Int(3)) 6 | let x: Int = Int(67890) 7 | Apply[](Var("print_int"), [If(Eq(Get(Var("y"), Int(0)), Int(3)), Prim(Prim(App(Var("f"), targs=Some([]), []), Get(Var("y"), Int(1)), Add, kind=Some(Int)), Var("x"), Add, kind=Some(Int)), Int(7)), ]) 8 | } 9 | Unit 10 | -------------------------------------------------------------------------------- /test/test_src/print.ans: -------------------------------------------------------------------------------- 1 | 123-456789 2 | -------------------------------------------------------------------------------- /test/test_src/print.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.1: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/print.knf.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Add(_8, _9) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.1, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Int(789) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.1, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Int(789) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.1, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Int(789) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.1, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.13: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Int(789) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.13, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.13: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Int(789) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.13, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.13: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Int(789) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.13, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec main.13: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Int(789) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.13, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec main.13: Unit = () { 2 | let _2: Int = Int(123) 3 | let _4: Unit = ExtApply(minimbt_print_int, [_2, ]) 4 | let _5: Int = Int(-456) 5 | let _7: Unit = ExtApply(minimbt_print_int, [_5, ]) 6 | let _8: Int = Int(789) 7 | let _9: Int = Int(0) 8 | let _10: Int = Int(789) 9 | let _12: Unit = ExtApply(minimbt_print_int, [_10, ]) 10 | Unit 11 | } 12 | Apply(main.13, []) 13 | -------------------------------------------------------------------------------- /test/test_src/print.mbt: -------------------------------------------------------------------------------- 1 | fn main { 2 | let _ = print_int(123); 3 | let _ = print_int(-456); 4 | let _ = print_int(789 + 0); 5 | () 6 | }; -------------------------------------------------------------------------------- /test/test_src/print.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Var(None) { 2 | let _: Var(None) = Apply(Var("print_int"), [Int(123), ]) 3 | let _: Var(None) = Apply(Var("print_int"), [Neg(Int(456), kind=None), ]) 4 | let _: Var(None) = Apply(Var("print_int"), [Prim(Int(789), Int(0), Add, kind=None), ]) 5 | Unit 6 | } 7 | Unit 8 | -------------------------------------------------------------------------------- /test/test_src/print.typer.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | let _: Unit = Apply[](Var("print_int"), [Int(123), ]) 3 | let _: Unit = Apply[](Var("print_int"), [Neg(Int(456), kind=Some(Int)), ]) 4 | let _: Unit = Apply[](Var("print_int"), [Prim(Int(789), Int(0), Add, kind=Some(Int)), ]) 5 | Unit 6 | } 7 | Unit 8 | -------------------------------------------------------------------------------- /test/test_src/print.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | let _: Unit = Apply[](Var("print_int"), [Int(123), ]) 3 | let _: Unit = Apply[](Var("print_int"), [Neg(Int(456), kind=Some(Int)), ]) 4 | let _: Unit = Apply[](Var("print_int"), [Prim(Int(789), Int(0), Add, kind=Some(Int)), ]) 5 | Unit 6 | } 7 | Unit 8 | -------------------------------------------------------------------------------- /test/test_src/read.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {f.2: @hashset.of([]), main.1: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/read.knf.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let rec f.2: Unit = () { 3 | let x.3: Int = ExtApply(minimbt_read_int, []) 4 | let _4: Int = Int(-2147483648) 5 | if (x.3 == _4) then { 6 | ExtApply(minimbt_print_int, [x.3, ]) 7 | } else { 8 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 9 | Apply(f.2, []) 10 | } 11 | } 12 | Apply(f.2, []) 13 | } 14 | Apply(main.1, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let rec f.2: Unit = () { 3 | let x.3: Int = ExtApply(minimbt_read_int, []) 4 | let _4: Int = Int(-2147483648) 5 | if (x.3 == _4) then { 6 | ExtApply(minimbt_print_int, [x.3, ]) 7 | } else { 8 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 9 | Apply(f.2, []) 10 | } 11 | } 12 | Apply(f.2, []) 13 | } 14 | Apply(main.1, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let rec f.2: Unit = () { 3 | let x.3: Int = ExtApply(minimbt_read_int, []) 4 | let _4: Int = Int(-2147483648) 5 | if (x.3 == _4) then { 6 | ExtApply(minimbt_print_int, [x.3, ]) 7 | } else { 8 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 9 | Apply(f.2, []) 10 | } 11 | } 12 | Apply(f.2, []) 13 | } 14 | Apply(main.1, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec main.1: Unit = () { 2 | let rec f.2: Unit = () { 3 | let x.3: Int = ExtApply(minimbt_read_int, []) 4 | let _4: Int = Int(-2147483648) 5 | if (x.3 == _4) then { 6 | ExtApply(minimbt_print_int, [x.3, ]) 7 | } else { 8 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 9 | Apply(f.2, []) 10 | } 11 | } 12 | Apply(f.2, []) 13 | } 14 | Apply(main.1, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec f.8: Unit = () { 2 | let x.3: Int = ExtApply(minimbt_read_int, []) 3 | let _4: Int = Int(-2147483648) 4 | if (x.3 == _4) then { 5 | ExtApply(minimbt_print_int, [x.3, ]) 6 | } else { 7 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 8 | Apply(f.8, []) 9 | } 10 | } 11 | let rec main.7: Unit = () { 12 | Apply(f.8, []) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec f.8: Unit = () { 2 | let x.3: Int = ExtApply(minimbt_read_int, []) 3 | let _4: Int = Int(-2147483648) 4 | if (x.3 == _4) then { 5 | ExtApply(minimbt_print_int, [x.3, ]) 6 | } else { 7 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 8 | Apply(f.8, []) 9 | } 10 | } 11 | let rec main.7: Unit = () { 12 | Apply(f.8, []) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec f.8: Unit = () { 2 | let x.3: Int = ExtApply(minimbt_read_int, []) 3 | let _4: Int = Int(-2147483648) 4 | if (x.3 == _4) then { 5 | ExtApply(minimbt_print_int, [x.3, ]) 6 | } else { 7 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 8 | Apply(f.8, []) 9 | } 10 | } 11 | let rec main.7: Unit = () { 12 | Apply(f.8, []) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec f.8: Unit = () { 2 | let x.3: Int = ExtApply(minimbt_read_int, []) 3 | let _4: Int = Int(-2147483648) 4 | if (x.3 == _4) then { 5 | ExtApply(minimbt_print_int, [x.3, ]) 6 | } else { 7 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 8 | Apply(f.8, []) 9 | } 10 | } 11 | let rec main.7: Unit = () { 12 | Apply(f.8, []) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec f.8: Unit = () { 2 | let x.3: Int = ExtApply(minimbt_read_int, []) 3 | let _4: Int = Int(-2147483648) 4 | if (x.3 == _4) then { 5 | ExtApply(minimbt_print_int, [x.3, ]) 6 | } else { 7 | let _6: Unit = ExtApply(minimbt_print_int, [x.3, ]) 8 | Apply(f.8, []) 9 | } 10 | } 11 | let rec main.7: Unit = () { 12 | Apply(f.8, []) 13 | } 14 | Apply(main.7, []) 15 | -------------------------------------------------------------------------------- /test/test_src/read.mbt: -------------------------------------------------------------------------------- 1 | //:has_read 2 | 3 | fn main { 4 | fn f() { 5 | let x = read_int(); 6 | // check int min 7 | if x == -2147483648 { 8 | print_int(x) 9 | } else { 10 | print_int(x); 11 | f() 12 | } 13 | }; 14 | f() 15 | } -------------------------------------------------------------------------------- /test/test_src/read.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Var(None) { 2 | let rec f: () -> Var(None) { 3 | let x: Var(None) = Apply(Var("read_int"), []) 4 | if (Eq(Var("x"), Neg(Int(2147483648), kind=None))) then { 5 | Apply(Var("print_int"), [Var("x"), ]) 6 | } else { 7 | let _: Var(None) = Apply(Var("print_int"), [Var("x"), ]) 8 | Apply(Var("f"), []) 9 | } 10 | } 11 | Apply(Var("f"), []) 12 | } 13 | Unit 14 | -------------------------------------------------------------------------------- /test/test_src/read.typer.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | let rec f: () -> Unit { 3 | let x: Int = Apply[](Var("read_int"), []) 4 | if (Eq(Var("x"), Neg(Int(2147483648), kind=Some(Int)))) then { 5 | Apply[](Var("print_int"), [Var("x"), ]) 6 | } else { 7 | let _: Unit = Apply[](Var("print_int"), [Var("x"), ]) 8 | Apply[](Var("f"), []) 9 | } 10 | } 11 | Apply[](Var("f"), []) 12 | } 13 | Unit 14 | -------------------------------------------------------------------------------- /test/test_src/read.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec main: () -> Unit { 2 | let rec f: () -> Unit { 3 | let x: Int = Apply[](Var("read_int"), []) 4 | if (Eq(Var("x"), Neg(Int(2147483648), kind=Some(Int)))) then { 5 | Apply[](Var("print_int"), [Var("x"), ]) 6 | } else { 7 | let _: Unit = Apply[](Var("print_int"), [Var("x"), ]) 8 | Apply[](Var("f"), []) 9 | } 10 | } 11 | Apply[](Var("f"), []) 12 | } 13 | Unit 14 | -------------------------------------------------------------------------------- /test/test_src/shuffle.ans: -------------------------------------------------------------------------------- 1 | 214563 2 | -------------------------------------------------------------------------------- /test/test_src/shuffle.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.39: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/shuffle.mbt: -------------------------------------------------------------------------------- 1 | fn foo(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int) -> Unit { 2 | let _ = print_int(a); 3 | let _ = print_int(b); 4 | let _ = print_int(c); 5 | let _ = print_int(d); 6 | let _ = print_int(e); 7 | let _ = print_int(f); 8 | () 9 | }; 10 | 11 | fn bar(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int) -> Unit { 12 | foo(b, a, d, e, f, c) 13 | }; 14 | 15 | fn main { 16 | bar(1, 2, 3, 4, 5, 6) 17 | }; -------------------------------------------------------------------------------- /test/test_src/ski.mbt: -------------------------------------------------------------------------------- 1 | //:extension 2 | 3 | fn s[X, Y, Z](x : (Z) -> (Y) -> X) -> ((Z) -> Y) -> (Z) -> X { 4 | fn f(y) { fn g(z) { x(z)(y(z)) }; g }; 5 | f 6 | }; 7 | fn k[X, Y] (x : X) -> (Y) -> X { 8 | fn f(y){ x }; f 9 | }; 10 | fn i[X](x : X) -> X { x }; 11 | 12 | fn main { 13 | let rev_apply = s(k(s(i)))(k); 14 | fn printi(x : Int) { print_int(x) }; 15 | rev_apply(2)(printi) 16 | }; 17 | -------------------------------------------------------------------------------- /test/test_src/spill.ans: -------------------------------------------------------------------------------- 1 | -431 2 | -------------------------------------------------------------------------------- /test/test_src/spill.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.83: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/spill2.ans: -------------------------------------------------------------------------------- 1 | 77880 2 | -------------------------------------------------------------------------------- /test/test_src/spill2.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.6: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/spill3.ans: -------------------------------------------------------------------------------- 1 | 1617 2 | -------------------------------------------------------------------------------- /test/test_src/spill3.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {main.93: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/split.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {rec.2: @hashset.of([]), main.21: @hashset.of([rec.2])} 2 | -------------------------------------------------------------------------------- /test/test_src/split.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec rec.2: Unit = (n.4: Int) { 2 | let _5: Int = Int(42) 3 | if (n.4 == _5) then { 4 | let _7: Int = Int(5) 5 | Unit 6 | } else { 7 | let _8: Int = Int(1) 8 | let _9: Int = Add(n.4, _8) 9 | Apply(rec.2, [_9, ]) 10 | } 11 | } 12 | let rec main.21: Unit = () { 13 | let _25: Int = Int(5) 14 | let _26: Int = Int(5) 15 | let _27: Int = Int(5) 16 | let _28: Int = Int(5) 17 | let _29: Int = Int(5) 18 | let _23: Unit = Unit 19 | let _24: Int = Int(0) 20 | Apply(rec.2, [_24, ]) 21 | } 22 | Apply(main.21, []) 23 | -------------------------------------------------------------------------------- /test/test_src/split.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec rec.2: Unit = (n.4: Int) { 2 | let _5: Int = Int(42) 3 | if (n.4 == _5) then { 4 | let _7: Int = Int(5) 5 | Unit 6 | } else { 7 | let _8: Int = Int(1) 8 | let _9: Int = Add(n.4, _8) 9 | Apply(rec.2, [_9, ]) 10 | } 11 | } 12 | let rec main.21: Unit = () { 13 | let _25: Int = Int(5) 14 | let _26: Int = Int(5) 15 | let _27: Int = Int(5) 16 | let _28: Int = Int(5) 17 | let _29: Int = Int(5) 18 | let _23: Unit = Unit 19 | let _24: Int = Int(0) 20 | Apply(rec.2, [_24, ]) 21 | } 22 | Apply(main.21, []) 23 | -------------------------------------------------------------------------------- /test/test_src/split.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec rec.2: Unit = (n.4: Int) { 2 | let _5: Int = Int(42) 3 | if (n.4 == _5) then { 4 | let _7: Int = Int(5) 5 | Unit 6 | } else { 7 | let _8: Int = Int(1) 8 | let _9: Int = Add(n.4, _8) 9 | Apply(rec.2, [_9, ]) 10 | } 11 | } 12 | let rec main.21: Unit = () { 13 | let _25: Int = Int(5) 14 | let _26: Int = Int(5) 15 | let _27: Int = Int(5) 16 | let _28: Int = Int(5) 17 | let _29: Int = Int(5) 18 | let _23: Unit = Unit 19 | let _24: Int = Int(0) 20 | Apply(rec.2, [_24, ]) 21 | } 22 | Apply(main.21, []) 23 | -------------------------------------------------------------------------------- /test/test_src/split.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec rec.30: Unit = (n.4: Int) { 2 | let _5: Int = Int(42) 3 | if (n.4 == _5) then { 4 | let _7: Int = Int(5) 5 | Unit 6 | } else { 7 | let _8: Int = Int(1) 8 | let _9: Int = Add(n.4, _8) 9 | Apply(rec.30, [_9, ]) 10 | } 11 | } 12 | let rec main.31: Unit = () { 13 | let _25: Int = Int(5) 14 | let _26: Int = Int(5) 15 | let _27: Int = Int(5) 16 | let _28: Int = Int(5) 17 | let _29: Int = Int(5) 18 | let _23: Unit = Unit 19 | let _24: Int = Int(0) 20 | Apply(rec.30, [_24, ]) 21 | } 22 | Apply(main.31, []) 23 | -------------------------------------------------------------------------------- /test/test_src/split.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec rec.30: Unit = (n.4: Int) { 2 | let _5: Int = Int(42) 3 | if (n.4 == _5) then { 4 | let _7: Int = Int(5) 5 | Unit 6 | } else { 7 | let _8: Int = Int(1) 8 | let _9: Int = Add(n.4, _8) 9 | Apply(rec.30, [_9, ]) 10 | } 11 | } 12 | let rec main.31: Unit = () { 13 | let _25: Int = Int(5) 14 | let _26: Int = Int(5) 15 | let _27: Int = Int(5) 16 | let _28: Int = Int(5) 17 | let _29: Int = Int(5) 18 | let _23: Unit = Unit 19 | let _24: Int = Int(0) 20 | Apply(rec.30, [_24, ]) 21 | } 22 | Apply(main.31, []) 23 | -------------------------------------------------------------------------------- /test/test_src/split.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec rec.30: Unit = (n.4: Int) { 2 | let _5: Int = Int(42) 3 | if (n.4 == _5) then { 4 | let _7: Int = Int(5) 5 | Unit 6 | } else { 7 | let _8: Int = Int(1) 8 | let _9: Int = Add(n.4, _8) 9 | Apply(rec.30, [_9, ]) 10 | } 11 | } 12 | let rec main.31: Unit = () { 13 | let _25: Int = Int(5) 14 | let _26: Int = Int(5) 15 | let _27: Int = Int(5) 16 | let _28: Int = Int(5) 17 | let _29: Int = Int(5) 18 | let _23: Unit = Unit 19 | let _24: Int = Int(0) 20 | Apply(rec.30, [_24, ]) 21 | } 22 | Apply(main.31, []) 23 | -------------------------------------------------------------------------------- /test/test_src/split.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec rec.30: Unit = (n.4: Int) { 2 | let _5: Int = Int(42) 3 | if (n.4 == _5) then { 4 | let _7: Int = Int(5) 5 | Unit 6 | } else { 7 | let _8: Int = Int(1) 8 | let _9: Int = Add(n.4, _8) 9 | Apply(rec.30, [_9, ]) 10 | } 11 | } 12 | let rec main.31: Unit = () { 13 | let _25: Int = Int(5) 14 | let _26: Int = Int(5) 15 | let _27: Int = Int(5) 16 | let _28: Int = Int(5) 17 | let _29: Int = Int(5) 18 | let _23: Unit = Unit 19 | let _24: Int = Int(0) 20 | Apply(rec.30, [_24, ]) 21 | } 22 | Apply(main.31, []) 23 | -------------------------------------------------------------------------------- /test/test_src/split.mbt: -------------------------------------------------------------------------------- 1 | fn small() -> Int { 2 | 5 3 | }; 4 | 5 | fn rec(n : Int) -> Unit { 6 | if n == 42 { 7 | let _ = small(); 8 | () 9 | } else { 10 | rec(n+1) 11 | } 12 | }; 13 | 14 | fn dummy() -> Unit { 15 | let _ = small(); 16 | let _ = small(); 17 | let _ = small(); 18 | let _ = small(); 19 | let _ = small(); 20 | () 21 | }; 22 | 23 | fn main { 24 | dummy(); 25 | rec(0) 26 | }; -------------------------------------------------------------------------------- /test/test_src/sum-prefix-escape.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {sum_nested.35: @hashset.of([res.34, arr.28]), main.25: @hashset.of([])} 2 | -------------------------------------------------------------------------------- /test/test_src/sum-prefix-escape.mbt: -------------------------------------------------------------------------------- 1 | fn sum_prefix(arr: Array[Int], len: Int) -> Array[Int] { 2 | let res = Array::make(len, 0); 3 | fn sum_nested(acc: Int, x: Int) -> Unit { 4 | if x <= len - 1 { 5 | let s = acc + arr[x]; 6 | res[x] = s; 7 | sum_nested(s, x + 1) 8 | } else { 9 | () 10 | } 11 | }; 12 | sum_nested(0, 0); 13 | res 14 | }; 15 | 16 | fn main { 17 | let arr = Array::make(10, 4); 18 | print_int(sum_prefix(arr, 10)[0]) 19 | }; 20 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.ans: -------------------------------------------------------------------------------- 1 | 50005000 2 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {sum.1: @hashset.of([]), main.10: @hashset.of([sum.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf.txt: -------------------------------------------------------------------------------- 1 | let rec sum.1: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.1, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.10: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.1, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.10, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec sum.1: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.1, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.10: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.1, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.10, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec sum.1: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.1, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.10: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.1, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.10, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec sum.1: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.1, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.10: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.1, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.10, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec sum.14: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.14, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.15: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.14, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.15, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec sum.14: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.14, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.15: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.14, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.15, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec sum.14: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.14, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.15: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.14, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.15, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec sum.14: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.14, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.15: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.14, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.15, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec sum.14: Int = (acc.3: Int, x.5: Int) { 2 | let _6: Int = Int(0) 3 | if (x.5 <= _6) then { 4 | Var(acc.3) 5 | } else { 6 | let _7: Int = Add(acc.3, x.5) 7 | let _8: Int = Int(1) 8 | let _9: Int = Sub(x.5, _8) 9 | Apply(sum.14, [_7, _9, ]) 10 | } 11 | } 12 | let rec main.15: Unit = () { 13 | let _11: Int = Int(0) 14 | let _12: Int = Int(10000) 15 | let _13: Int = Apply(sum.14, [_11, _12, ]) 16 | ExtApply(minimbt_print_int, [_13, ]) 17 | } 18 | Apply(main.15, []) 19 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.mbt: -------------------------------------------------------------------------------- 1 | fn sum(acc: Int, x: Int) -> Int { 2 | if x <= 0 { 3 | acc 4 | } else { 5 | sum(acc + x, x - 1) 6 | } 7 | }; 8 | 9 | fn main { 10 | print_int(sum(0, 10000)) 11 | }; -------------------------------------------------------------------------------- /test/test_src/sum-tail.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec sum: (acc: Int, x: Int) -> Int { 2 | if (LE(Var("x"), Int(0))) then { 3 | Var(acc) 4 | } else { 5 | Apply(Var("sum"), [Prim(Var("acc"), Var("x"), Add, kind=None), Prim(Var("x"), Int(1), Sub, kind=None), ]) 6 | } 7 | } 8 | let rec main: () -> Var(None) { 9 | Apply(Var("print_int"), [App(Var("sum"), targs=None, [Int(0), Int(10000)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.typer.txt: -------------------------------------------------------------------------------- 1 | let rec sum: (acc: Int, x: Int) -> Int { 2 | if (LE(Var("x"), Int(0))) then { 3 | Var(acc) 4 | } else { 5 | Apply[](Var("sum"), [Prim(Var("acc"), Var("x"), Add, kind=Some(Int)), Prim(Var("x"), Int(1), Sub, kind=Some(Int)), ]) 6 | } 7 | } 8 | let rec main: () -> Unit { 9 | Apply[](Var("print_int"), [App(Var("sum"), targs=Some([]), [Int(0), Int(10000)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/sum-tail.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec sum: (acc: Int, x: Int) -> Int { 2 | if (LE(Var("x"), Int(0))) then { 3 | Var(acc) 4 | } else { 5 | Apply[](Var("sum"), [Prim(Var("acc"), Var("x"), Add, kind=Some(Int)), Prim(Var("x"), Int(1), Sub, kind=Some(Int)), ]) 6 | } 7 | } 8 | let rec main: () -> Unit { 9 | Apply[](Var("print_int"), [App(Var("sum"), targs=Some([]), [Int(0), Int(10000)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/sum.ans: -------------------------------------------------------------------------------- 1 | 50005000 2 | -------------------------------------------------------------------------------- /test/test_src/sum.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {sum.1: @hashset.of([]), main.8: @hashset.of([sum.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/sum.knf.txt: -------------------------------------------------------------------------------- 1 | let rec sum.1: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.1, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.8: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.1, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.8, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.knf_after_inline_0.txt: -------------------------------------------------------------------------------- 1 | let rec sum.1: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.1, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.8: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.1, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.8, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.knf_after_inline_1.txt: -------------------------------------------------------------------------------- 1 | let rec sum.1: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.1, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.8: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.1, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.8, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.knf_after_inline_2.txt: -------------------------------------------------------------------------------- 1 | let rec sum.1: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.1, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.8: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.1, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.8, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.knf_after_licm_0.txt: -------------------------------------------------------------------------------- 1 | let rec sum.11: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.11, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.12: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.11, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.knf_after_licm_1.txt: -------------------------------------------------------------------------------- 1 | let rec sum.11: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.11, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.12: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.11, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.knf_after_licm_2.txt: -------------------------------------------------------------------------------- 1 | let rec sum.11: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.11, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.12: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.11, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.knf_after_lifting.txt: -------------------------------------------------------------------------------- 1 | let rec sum.11: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.11, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.12: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.11, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.knf_after_unbox.txt: -------------------------------------------------------------------------------- 1 | let rec sum.11: Int = (x.3: Int) { 2 | let _4: Int = Int(0) 3 | if (x.3 <= _4) then { 4 | Int(0) 5 | } else { 6 | let _5: Int = Int(1) 7 | let _6: Int = Sub(x.3, _5) 8 | let _7: Int = Apply(sum.11, [_6, ]) 9 | Add(_7, x.3) 10 | } 11 | } 12 | let rec main.12: Unit = () { 13 | let _9: Int = Int(10000) 14 | let _10: Int = Apply(sum.11, [_9, ]) 15 | ExtApply(minimbt_print_int, [_10, ]) 16 | } 17 | Apply(main.12, []) 18 | -------------------------------------------------------------------------------- /test/test_src/sum.mbt: -------------------------------------------------------------------------------- 1 | fn sum(x: Int) -> Int { 2 | if x <= 0 { 3 | 0 4 | } else { 5 | sum(x - 1) + x 6 | } 7 | }; 8 | 9 | fn main { 10 | print_int(sum(10000)) 11 | }; -------------------------------------------------------------------------------- /test/test_src/sum.resolved.txt: -------------------------------------------------------------------------------- 1 | let rec sum: (x: Int) -> Int { 2 | if (LE(Var("x"), Int(0))) then { 3 | Int(0) 4 | } else { 5 | App(Var("sum"), targs=None, [Prim(Var("x"), Int(1), Sub, kind=None)]) + Var("x") 6 | } 7 | } 8 | let rec main: () -> Var(None) { 9 | Apply(Var("print_int"), [App(Var("sum"), targs=None, [Int(10000)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/sum.typer.txt: -------------------------------------------------------------------------------- 1 | let rec sum: (x: Int) -> Int { 2 | if (LE(Var("x"), Int(0))) then { 3 | Int(0) 4 | } else { 5 | App(Var("sum"), targs=Some([]), [Prim(Var("x"), Int(1), Sub, kind=Some(Int))]) + Var("x") 6 | } 7 | } 8 | let rec main: () -> Unit { 9 | Apply[](Var("print_int"), [App(Var("sum"), targs=Some([]), [Int(10000)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/sum.typer_simplified.txt: -------------------------------------------------------------------------------- 1 | let rec sum: (x: Int) -> Int { 2 | if (LE(Var("x"), Int(0))) then { 3 | Int(0) 4 | } else { 5 | App(Var("sum"), targs=Some([]), [Prim(Var("x"), Int(1), Sub, kind=Some(Int))]) + Var("x") 6 | } 7 | } 8 | let rec main: () -> Unit { 9 | Apply[](Var("print_int"), [App(Var("sum"), targs=Some([]), [Int(10000)]), ]) 10 | } 11 | Unit 12 | -------------------------------------------------------------------------------- /test/test_src/typeclass.mbt: -------------------------------------------------------------------------------- 1 | //:extension 2 | 3 | class Print[T] { 4 | print : T -> Unit; 5 | }; 6 | 7 | instance Print[Int] { 8 | print = { fn aux(x) { print_int(x) }; aux }; 9 | }; 10 | 11 | instance Print[String] { 12 | print = { fn aux(x) { print_string(x) }; aux }; 13 | }; 14 | 15 | fn print_generic[P: Print, X](p : P, _dummy: X) -> Unit { 16 | print(p) 17 | }; 18 | 19 | fn main { 20 | print_generic(1, 0.1); 21 | print_generic("\n", ()); 22 | print_generic("Hello Moonbit", 2); 23 | } 24 | 25 | -------------------------------------------------------------------------------- /test/test_src/user_defined_op.free_set_closure.txt: -------------------------------------------------------------------------------- 1 | {pow.1: @hashset.of([]), main.17: @hashset.of([pow.1])} 2 | -------------------------------------------------------------------------------- /test/test_src/user_defined_op.mbt: -------------------------------------------------------------------------------- 1 | infix right 10 ** pow; 2 | infix left 10 *** pow; 3 | infix left 5 % mod; 4 | 5 | fn pow(x: Int, n: Int) -> Int { 6 | if n == 0 { 1 } else { x * pow(x, n - 1) } 7 | }; 8 | 9 | fn mod(x: Int, n: Int) -> Int { 10 | x - (x / n) * n 11 | }; 12 | 13 | fn main { 14 | print_int(2 ** 2 ** 3); 15 | print_char(10); 16 | print_int(2 *** 2 *** 3); 17 | print_char(10); 18 | print_int(66434 % 100); 19 | print_char(10); 20 | } 21 | 22 | --------------------------------------------------------------------------------